@dogpile/sdk 0.1.2 → 0.2.1

package/src/runtime/sequential.test.ts

@@ -1,262 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createDeterministicModelProvider } from "../internal.js";
-import { Dogpile, run, runtimeToolManifest, stream } from "../index.js";
-import type { ConfiguredModelProvider, JsonObject, ModelRequest, RunEvent, RuntimeTool } from "../index.js";
-
-describe("sequential protocol", () => {
-  it("uses the ergonomic default flow when protocol and tier are omitted", async () => {
-    const result = await Dogpile.pile({
-      intent: "Draft a release note for a portable multi-agent SDK.",
-      model: createDeterministicModelProvider("default-flow-model")
-    });
-
-    expect(result.output).toContain("synthesizer:agent-3");
-    expect(result.transcript).toHaveLength(3);
-    expect(result.trace.protocol).toBe("sequential");
-    expect(result.trace.tier).toBe("balanced");
-    expect(result.trace.modelProviderId).toBe("default-flow-model");
-  });
-
-  it("runs end-to-end against a configured model provider", async () => {
-    const result = await run({
-      intent: "Draft a release note for a portable multi-agent SDK.",
-      protocol: "sequential",
-      tier: "fast",
-      model: createDeterministicModelProvider()
-    });
-
-    expect(result.output).toContain("synthesizer:agent-3");
-    expect(result.transcript).toHaveLength(3);
-    expect(result.trace.protocol).toBe("sequential");
-    expect(result.trace.modelProviderId).toBe("deterministic-test-model");
-    expect(result.trace.events.map((event) => event.type)).toEqual([
-      "role-assignment",
-      "role-assignment",
-      "role-assignment",
-      "agent-turn",
-      "agent-turn",
-      "agent-turn",
-      "final"
-    ]);
-    expect(JSON.parse(JSON.stringify(result.trace))).toEqual(result.trace);
-    expect(result.cost.totalTokens).toBeGreaterThan(0);
-  });
-
-  it("passes a caller AbortSignal through every sequential model request", async () => {
-    const abortController = new AbortController();
-    const requests: ModelRequest[] = [];
-    const model: ConfiguredModelProvider = {
-      id: "abort-signal-model",
-      async generate(request) {
-        requests.push(request);
-        return { text: `turn-${requests.length}` };
-      }
-    };
-
-    const result = await run({
-      intent: "Verify cancellation plumbing reaches the provider adapter.",
-      protocol: { kind: "sequential", maxTurns: 2 },
-      tier: "fast",
-      model,
-      signal: abortController.signal
-    });
-
-    expect(requests).toHaveLength(2);
-    expect(requests.map((request) => request.signal)).toEqual([
-      abortController.signal,
-      abortController.signal
-    ]);
-    expect(result.trace.providerCalls.map((call) => call.request.signal)).toEqual([
-      undefined,
-      undefined
-    ]);
-    expect(JSON.parse(JSON.stringify(result.trace))).toEqual(result.trace);
-  });
-
-  it("records autonomous decisions and skips abstentions when choosing the final output", async () => {
-    const responses = [
-      [
-        "role_selected: upload workflow analyst",
-        "participation: contribute",
-        "rationale: This starts the plan with the user journey.",
-        "contribution:",
-        "Contribution from the first agent."
-      ].join("\n"),
-      [
-        "role_selected: duplicate reviewer",
-        "participation: abstain",
-        "rationale: The prior output already covers this slice.",
-        "contribution:",
-        "No additional contribution is needed."
-      ].join("\n")
-    ];
-    const model: ConfiguredModelProvider = {
-      id: "sequential-decision-model",
-      async generate() {
-        return { text: responses.shift() ?? "unused" };
-      }
-    };
-
-    const result = await run({
-      intent: "Plan a Hugging Face upload GUI.",
-      protocol: { kind: "sequential", maxTurns: 2 },
-      tier: "fast",
-      model,
-      agents: [
-        { id: "agent-0", role: "autonomous-agent" },
-        { id: "agent-1", role: "autonomous-agent" }
-      ]
-    });
-
-    expect(result.output).toContain("Contribution from the first agent.");
-    expect(result.output).not.toContain("No additional contribution is needed.");
-    expect(result.transcript[0]?.decision).toMatchObject({
-      selectedRole: "upload workflow analyst",
-      participation: "contribute"
-    });
-    expect(result.transcript[1]?.decision).toMatchObject({
-      selectedRole: "duplicate reviewer",
-      participation: "abstain"
-    });
-    const turnEvents = result.trace.events.filter((event) => event.type === "agent-turn");
-    expect(turnEvents[1]?.type).toBe("agent-turn");
-    if (turnEvents[1]?.type !== "agent-turn") {
-      throw new Error("expected second turn event");
-    }
-    expect(turnEvents[1].decision?.participation).toBe("abstain");
-  });
-
-  it("streams the same coordination moments before resolving the final result", async () => {
-    const handle = stream({
-      intent: "Summarize the value of sequential agent collaboration.",
-      protocol: { kind: "sequential", maxTurns: 2 },
-      tier: "balanced",
-      model: createDeterministicModelProvider("configured-stream-model")
-    });
-
-    const events = [];
-    for await (const event of handle) {
-      events.push(event.type);
-    }
-    const result = await handle.result;
-
-    expect(events).toEqual([
-      "role-assignment",
-      "role-assignment",
-      "agent-turn",
-      "agent-turn",
-      "final"
-    ]);
-    expect(result.output).toContain("critic:agent-2");
-    expect(result.trace.modelProviderId).toBe("configured-stream-model");
-  });
-
-  it("streams role-assignment events with agent ids and roles before agent work events", async () => {
-    const handle = Dogpile.stream({
-      intent: "Verify role assignment streaming before work starts.",
-      protocol: { kind: "sequential", maxTurns: 2 },
-      tier: "balanced",
-      model: createDeterministicModelProvider("role-stream-model"),
-      agents: [
-        { id: "planner-seat", role: "planner" },
-        { id: "reviewer-seat", role: "reviewer" }
-      ]
-    });
-
-    const streamedEvents: RunEvent[] = [];
-    for await (const event of handle) {
-      if (event.type !== "error") {
-        streamedEvents.push(event as RunEvent);
-      }
-    }
-    const result = await handle.result;
-
-    expect(streamedEvents.map((event) => event.type)).toEqual([
-      "role-assignment",
-      "role-assignment",
-      "agent-turn",
-      "agent-turn",
-      "final"
-    ]);
-    expect(streamedEvents.slice(0, 2)).toEqual([
-      expect.objectContaining({
-        type: "role-assignment",
-        runId: result.trace.runId,
-        agentId: "planner-seat",
-        role: "planner"
-      }),
-      expect.objectContaining({
-        type: "role-assignment",
-        runId: result.trace.runId,
-        agentId: "reviewer-seat",
-        role: "reviewer"
-      })
-    ]);
-    expect(result.trace.events).toEqual(streamedEvents);
-  });
-
-  it("threads runtime tool availability through every sequential model turn", async () => {
-    interface LookupInput extends JsonObject {
-      readonly query: string;
-    }
-
-    interface LookupOutput extends JsonObject {
-      readonly answer: string;
-    }
-
-    const requests: ModelRequest[] = [];
-    const lookupTool: RuntimeTool<LookupInput, LookupOutput> = {
-      identity: {
-        id: "fixture.lookup",
-        name: "lookup",
-        description: "Lookup contextual facts for the active mission."
-      },
-      inputSchema: {
-        kind: "json-schema",
-        schema: {
-          type: "object",
-          properties: {
-            query: { type: "string" }
-          },
-          required: ["query"],
-          additionalProperties: false
-        }
-      },
-      execute(input, context) {
-        return {
-          type: "success",
-          toolCallId: context.toolCallId,
-          tool: this.identity,
-          output: {
-            answer: `found:${input.query}`
-          }
-        };
-      }
-    };
-    const model: ConfiguredModelProvider = {
-      id: "sequential-tool-availability-model",
-      async generate(request) {
-        requests.push(request);
-        return { text: `turn-${requests.length}` };
-      }
-    };
-
-    await run({
-      intent: "Use available tools while composing a release note.",
-      protocol: { kind: "sequential", maxTurns: 2 },
-      tier: "fast",
-      model,
-      agents: [
-        { id: "researcher-seat", role: "researcher" },
-        { id: "writer-seat", role: "writer" }
-      ],
-      tools: [lookupTool]
-    });
-
-    expect(requests).toHaveLength(2);
-    expect(requests.map((request) => request.metadata.tools)).toEqual([
-      runtimeToolManifest([lookupTool]),
-      runtimeToolManifest([lookupTool])
-    ]);
-  });
-});

package/src/runtime/shared.test.ts

@@ -1,265 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createDeterministicSharedTestMission } from "../internal.js";
-import { Dogpile, run, runtimeToolManifest } from "../index.js";
-import type {
-  ConfiguredModelProvider,
-  JsonObject,
-  ModelRequest,
-  ModelResponse,
-  RunEvent,
-  RuntimeTool
-} from "../index.js";
-
-describe("shared protocol", () => {
-  it("executes end-to-end through the branded high-level SDK call", async () => {
-    const result = await Dogpile.pile(createDeterministicSharedTestMission());
-
-    expect(result.output).toBe(
-      [
-        "state-initializer:agent-1 => state-initializer:agent-1 initialized the shared state.",
-        "state-reviewer:agent-2 => state-reviewer:agent-2 initialized the shared state.",
-        "state-synthesizer:agent-3 => state-synthesizer:agent-3 initialized the shared state."
-      ].join("\n")
-    );
-    expect(result.trace.protocol).toBe("shared");
-    expect(result.trace.modelProviderId).toBe("deterministic-shared-model");
-    expect(result.trace.events.map((event) => event.type)).toEqual([
-      "role-assignment",
-      "role-assignment",
-      "role-assignment",
-      "agent-turn",
-      "agent-turn",
-      "agent-turn",
-      "final"
-    ]);
-    expect(result.transcript).toHaveLength(3);
-    expect(result.trace.transcript).toEqual(result.transcript);
-    expect(JSON.parse(JSON.stringify(result.trace))).toEqual(result.trace);
-    expect(result.cost.totalTokens).toBeGreaterThan(0);
-  });
-
-  it("runs a deterministic shared-state test mission against the configured model provider", async () => {
-    const requests: ModelRequest[] = [];
-    const model: ConfiguredModelProvider = {
-      id: "configured-shared-model",
-      async generate(request: ModelRequest): Promise<ModelResponse> {
-        requests.push(request);
-        const agentId = String(request.metadata.agentId);
-        const role = String(request.metadata.role);
-        const turn = Number(request.metadata.turn);
-
-        return {
-          text: `${role}:${agentId} wrote shared turn ${turn}.`,
-          usage: {
-            inputTokens: 9,
-            outputTokens: 5,
-            totalTokens: 14
-          },
-          costUsd: 0.001
-        };
-      }
-    };
-
-    const result = await run(createDeterministicSharedTestMission(model));
-
-    expect(requests).toHaveLength(3);
-    expect(result.trace.protocol).toBe("shared");
-    expect(result.trace.modelProviderId).toBe("configured-shared-model");
-    expect(result.trace.events.map((event) => event.type)).toEqual([
-      "role-assignment",
-      "role-assignment",
-      "role-assignment",
-      "agent-turn",
-      "agent-turn",
-      "agent-turn",
-      "final"
-    ]);
-
-    for (const [index, request] of requests.entries()) {
-      const turn = index + 1;
-      const userMessage = request.messages.find((message) => message.role === "user");
-      const systemMessage = request.messages.find((message) => message.role === "system");
-
-      expect(request.metadata).toMatchObject({
-        protocol: "shared",
-        tier: "fast",
-        turn
-      });
-      expect(userMessage?.content).toContain("Decide whether the shared protocol can support portable replay.");
-      expect(userMessage?.content).toContain(`Shared turn ${turn}`);
-      expect(userMessage?.content).toContain("Shared state:");
-      expect(systemMessage?.content).toContain("Shared multi-agent protocol");
-    }
-
-    expect(requests[0]?.messages.find((message) => message.role === "user")?.content).toContain("(empty)");
-    expect(requests[1]?.messages.find((message) => message.role === "user")?.content).toContain("(empty)");
-    expect(requests[2]?.messages.find((message) => message.role === "user")?.content).toContain("(empty)");
-    expect(requests[1]?.messages.find((message) => message.role === "user")?.content).not.toContain(
-      "state-initializer:agent-1 =>"
-    );
-    expect(result.output).toBe(
-      [
-        "state-initializer:agent-1 => state-initializer:agent-1 wrote shared turn 1.",
-        "state-reviewer:agent-2 => state-reviewer:agent-2 wrote shared turn 2.",
-        "state-synthesizer:agent-3 => state-synthesizer:agent-3 wrote shared turn 3."
-      ].join("\n")
-    );
-    expect(result.transcript).toHaveLength(3);
-    expect(result.trace.transcript).toEqual(result.transcript);
-    expect(JSON.parse(JSON.stringify(result.trace))).toEqual(result.trace);
-    expect(result.cost.totalTokens).toBe(42);
-  });
-
-  it("streams shared coordination events through the high-level SDK handle", async () => {
-    const handle = Dogpile.stream(createDeterministicSharedTestMission());
-
-    const streamedEvents: RunEvent[] = [];
-    for await (const event of handle) {
-      if (event.type !== "error") {
-        streamedEvents.push(event as RunEvent);
-      }
-    }
-    const result = await handle.result;
-
-    const expectedOutput = [
-      "state-initializer:agent-1 => state-initializer:agent-1 initialized the shared state.",
-      "state-reviewer:agent-2 => state-reviewer:agent-2 initialized the shared state.",
-      "state-synthesizer:agent-3 => state-synthesizer:agent-3 initialized the shared state."
-    ].join("\n");
-
-    expect(result.output).toBe(expectedOutput);
-    expect(streamedEvents.map((event) => event.type)).toEqual([
-      "role-assignment",
-      "role-assignment",
-      "role-assignment",
-      "agent-turn",
-      "agent-turn",
-      "agent-turn",
-      "final"
-    ]);
-    expect(result.trace.events).toEqual(streamedEvents);
-    expect(result.transcript).toEqual([
-      {
-        agentId: "agent-1",
-        role: "state-initializer",
-        input:
-          "Mission: Decide whether the shared protocol can support portable replay.\nShared turn 1: read the shared state and return an improved shared-state update.\n\nShared state:\n(empty)",
-        output: "state-initializer:agent-1 initialized the shared state."
-      },
-      {
-        agentId: "agent-2",
-        role: "state-reviewer",
-        input:
-          "Mission: Decide whether the shared protocol can support portable replay.\nShared turn 2: read the shared state and return an improved shared-state update.\n\nShared state:\n(empty)",
-        output: "state-reviewer:agent-2 initialized the shared state."
-      },
-      {
-        agentId: "agent-3",
-        role: "state-synthesizer",
-        input:
-          "Mission: Decide whether the shared protocol can support portable replay.\nShared turn 3: read the shared state and return an improved shared-state update.\n\nShared state:\n(empty)",
-        output: "state-synthesizer:agent-3 initialized the shared state."
-      }
-    ]);
-    expect(result.trace.transcript).toEqual(result.transcript);
-  });
-
-  it("gives every shared agent the same organizational memory snapshot", async () => {
-    const requests: ModelRequest[] = [];
-    const model: ConfiguredModelProvider = {
-      id: "shared-memory-snapshot-model",
-      async generate(request) {
-        requests.push(request);
-        return { text: `output-${String(request.metadata.agentId)}` };
-      }
-    };
-
-    await run({
-      intent: "Coordinate from historical organization memory.",
-      protocol: {
-        kind: "shared",
-        maxTurns: 2,
-        organizationalMemory: "Prior task memory: uploader and verifier roles were useful."
-      },
-      tier: "fast",
-      model,
-      agents: [
-        { id: "agent-a", role: "autonomous-agent" },
-        { id: "agent-b", role: "autonomous-agent" }
-      ]
-    });
-
-    expect(requests).toHaveLength(2);
-    const userPrompts = requests.map((request) => request.messages.find((message) => message.role === "user")?.content);
-    expect(userPrompts).toEqual([
-      "Mission: Coordinate from historical organization memory.\nShared turn 1: read the shared state and return an improved shared-state update.\n\nShared state:\nPrior task memory: uploader and verifier roles were useful.",
-      "Mission: Coordinate from historical organization memory.\nShared turn 2: read the shared state and return an improved shared-state update.\n\nShared state:\nPrior task memory: uploader and verifier roles were useful."
-    ]);
-    expect(userPrompts[1]).not.toContain("output-agent-a");
-  });
-
-  it("threads runtime tool availability through every shared model turn", async () => {
-    interface LookupInput extends JsonObject {
-      readonly query: string;
-    }
-
-    interface LookupOutput extends JsonObject {
-      readonly answer: string;
-    }
-
-    const requests: ModelRequest[] = [];
-    const lookupTool: RuntimeTool<LookupInput, LookupOutput> = {
-      identity: {
-        id: "fixture.lookup",
-        name: "lookup",
-        description: "Lookup contextual facts for the active mission."
-      },
-      inputSchema: {
-        kind: "json-schema",
-        schema: {
-          type: "object",
-          properties: {
-            query: { type: "string" }
-          },
-          required: ["query"],
-          additionalProperties: false
-        }
-      },
-      execute(input, context) {
-        return {
-          type: "success",
-          toolCallId: context.toolCallId,
-          tool: this.identity,
-          output: {
-            answer: `found:${input.query}`
-          }
-        };
-      }
-    };
-    const model: ConfiguredModelProvider = {
-      id: "shared-tool-availability-model",
-      async generate(request) {
-        requests.push(request);
-        return { text: `turn-${requests.length}` };
-      }
-    };
-
-    await run({
-      intent: "Use available tools while updating shared state.",
-      protocol: { kind: "shared", maxTurns: 2 },
-      tier: "fast",
-      model,
-      agents: [
-        { id: "initializer-seat", role: "initializer" },
-        { id: "reviewer-seat", role: "reviewer" }
-      ],
-      tools: [lookupTool]
-    });
-
-    expect(requests).toHaveLength(2);
-    expect(requests.map((request) => request.metadata.tools)).toEqual([
-      runtimeToolManifest([lookupTool]),
-      runtimeToolManifest([lookupTool])
-    ]);
-  });
-});