subagents

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73// Run a tool call in its displayed subagent, or in the plugin owning a type.
// Model failures remain tool results, with the displayed run ended first.
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as z from "zod";
import { parse, promise } from "convergence/effect";
import type { Api, ToolContext } from "convergence";
import { TOOL, titleOf } from "./lib.ts";
import type { SpawnInput } from "./lib.ts";

class ModelFailed extends Data.TaggedError("ModelFailed")<{ readonly cause: unknown }> {}
const errorFields = z.object({ name: z.string().optional(), message: z.string().optional() });
const failed = (text: string) => ({ content: [{ type: "text", text }], isError: true });

export const spawn = Effect.fn("Subagents.spawn")(function* (
  api: { models: Pick<Api["models"], "prompt">; subagents: Pick<Api["subagents"], "run"> },
  input: SpawnInput,
  ctx: ToolContext,
) {
  const prompt = input.prompt.trim();
  if (!prompt) return failed(`${TOOL} needs a prompt.`);
  if (input.type) {
    const type = yield* parse("subagent type", z.string(), input.type);
    const result = yield* promise("subagents.run", () => api.subagents.run({ type, input: { ...input, prompt } }, ctx));
    return result ?? "The subagent finished without a result.";
  }
  const agentId = input.agent || ctx.agentId;
  if (!agentId) return failed("Name the agent to run the subagent on.");
  const subagent = yield* promise("subagent.start", () =>
    ctx.subagent.start({
      title: input.title || titleOf(prompt),
      agent: agentId,
      model: input.model,
      effort: input.effort,
      prompt,
    }),
  );
  return yield* Effect.tryPromise({
    try: () =>
      api.models.prompt({
        agentId,
        model: input.model,
        effort: input.effort,
        prompt,
        workspaceId: ctx.workspaceId,
        subagent,
        signal: ctx.signal,
      }),
    catch: (cause) => new ModelFailed({ cause }),
  }).pipe(
    Effect.map((answer) => {
      if (answer.status === "completed") {
        subagent.end({ status: "completed", summary: answer.text });
        return answer.text || "The subagent finished without a reply.";
      }
      const why =
        answer.status === "cancelled"
          ? "The subagent was stopped."
          : `The subagent failed: ${answer.message ?? "no reason given"}`;
      subagent.end({ status: answer.status === "cancelled" ? "cancelled" : "failed", summary: why });
      return failed(why);
    }),
    Effect.catchTag("ModelFailed", ({ cause }) =>
      Effect.sync(() => {
        const fields = errorFields.safeParse(cause);
        const stopped = fields.success && fields.data.name === "AbortError";
        const message = fields.success ? (fields.data.message ?? String(cause)) : String(cause);
        subagent.end({ status: stopped ? "cancelled" : "failed", summary: stopped ? "Stopped." : message });
        return failed(stopped ? "The subagent was stopped." : `The subagent could not run: ${message}`);
      }),
    ),
  );
});