Agents

interface AgentEntry {
  agent: AgentConfig;
  teamName: string;
}

interface AgentConfig {
  name: string;
  role?: string;
  model?: string;
  image_model?: string;
  video_model?: string;
  vision_model?: string;
  transcribe_model?: string;
  tts_model?: string;
  search_provider?: string;
  systemPrompt?: string;
  allowedTools?: string[];
  allowedPaths?: string[];
  skills?: string[];
  maxTurns?: number;
  maxConcurrency?: number;
  reasoning?: ReasoningLevel;
  runtime?: string;
  executionMode?: "subprocess" | "in-process";
  sandbox?: {
    isolation?: "reuse" | "fresh";
  };
  assignedLoops?: string[];
  /** Legacy inline loop config. Prefer project-level loops. */
  loops?: Record<string, LoopConfig>;
  /** Legacy inline loop wiring. Prefer project-level loops. */
  pipeline?: Pipeline;
  reportsTo?: string;
  identity?: AgentIdentity;
  volatile?: boolean;
  missionGroup?: string;
  /** Named persistent profile for browser_* tools.
   *  Empty/omitted defaults to the agent name. */
  browserProfile?: string;
  emailAllowedDomains?: string[];
  createdAt?: string;
  version?: string;
  author?: string;
  tags?: string[];
}

interface ProjectLoopConfig {
  name: string;
  description?: string;
  context?: "shared";
  start: string;
  steps: Record<string, LoopStepConfig>;
  permissions?: LoopPermission[];
  policies?: LoopPolicy[];
  hooks?: Record<LifecycleHook, HookAction[]>;
}

type LoopStepConfig =
  | (LoopConfig & { type?: "agent"; when?: string; next?: LoopNext })
  | { type: "tool"; when?: string; tool: string; input?: unknown; saveAs?: string; next?: LoopNext }
  | { type: "human"; when?: string; output?: { schema?: unknown }; notify?: string[]; next?: LoopNext }
  | { type: "parallel"; when?: string; branches: string[]; join?: "all" | "any" | number; next?: LoopNext };

type LoopNext = string | { when?: string; to: string }[];

export default defineLoop({
  name: "coding-flow",
  start: "plan",
  steps: {
    plan: agentStep({
      label: "Plan",
      systemPrompt: "Inspect the request and produce a concise implementation plan.",
      tools: ["read", "grep"],
      next: "build",
    }),
    build: agentStep({
      label: "Build",
      systemPrompt: "Implement and run the build.",
      tools: ["read", "write", "edit", "bash"],
      toolChoice: requireTool("bash"),
      next: [
        when("build.passed == true", "end"),
        otherwise("fix"),
      ],
    }),
    fix: agentStep({
      label: "Fix",
      systemPrompt: "Read the build output from context and make the smallest fix.",
      tools: ["read", "write", "edit", "bash"],
      next: "build",
    }),
  },
});

interface LoopConfig {
  name?: string;
  systemPrompt?: string;
  tools?: string[];
  toolChoice?: "auto" | "none" | "required" | { mode: "auto" | "none" | "required"; tool?: string };
  model?: string;
  reasoning?: ReasoningLevel | string;
  maxTurns?: number;
  stopWhen?: { expression: string };
  output?: { schema?: unknown };
}

interface Pipeline {
  mode?: "sequential" | "parallel";
  context?: "shared";
  steps: PipelineStep[];
}

type PipelineStep =
  | { loop: string; when?: string }
  | { tool: string; input?: unknown; saveAs?: string; when?: string }
  | { parallel: PipelineStep[]; join?: "all" | "any" | number; when?: string }
  | { switch: { cases: { when: string; steps: PipelineStep[] }[]; default?: { steps: PipelineStep[] } }; when?: string }
  | { human: string; output?: { schema?: unknown }; notify?: string[]; when?: string };

interface AgentIdentity {
  displayName?: string;
  title?: string;
  company?: string;
  email?: string;
  bio?: string;
  timezone?: string;
  avatar?: string;
  tone?: string;
  personality?: string;
  responsibilities?: (string | AgentResponsibility)[];
  socials?: Record<string, string>;
}

interface AgentResponsibility {
  area: string;
  description: string;
  priority?: "critical" | "high" | "medium" | "low";
}

{
  "name": "coding-flow",
  "description": "Plan and build with an approval gate.",
  "context": "shared",
  "start": "clone_repo",
  "steps": {
    "clone_repo": {
      "type": "tool",
      "tool": "clone_repository",
      "input": {
        "repoUrl": "https://github.com/acme/app.git",
        "targetDir": "workspace/app"
      },
      "saveAs": "repo.clone",
      "next": "plan"
    },
    "plan": {
      "type": "agent",
      "systemPrompt": "Create a short implementation plan.",
      "tools": ["read", "grep"],
      "next": "approval"
    },
    "approval": {
      "type": "human",
      "output": { "schema": { "decision": "string" } },
      "next": [
        { "when": "approval.decision == 'approve'", "to": "build" },
        { "to": "end" }
      ]
    },
    "build": {
      "type": "agent",
      "systemPrompt": "Implement the approved plan.",
      "tools": ["read", "write", "edit", "bash"],
      "toolChoice": { "mode": "required", "tool": "bash" },
      "next": "end"
    }
  },
  "permissions": [
    {
      "id": "approve-shell",
      "resource": "tool",
      "effect": "approval",
      "match": { "tool": "bash", "hook": "tool:before" },
      "message": "Approve shell execution before build."
    }
  ],
  "hooks": {
    "loop:start": [
      {
        "tool": "audit_event",
        "input": { "event": "coding-flow-started" },
        "saveAs": "audit.started"
      }
    ],
    "loop:end": [
      {
        "tool": "audit_event",
        "input": { "event": "coding-flow-ended" },
        "saveAs": "audit.ended",
        "onError": "continue"
      }
    ]
  }
}

interface ProjectLoop {
  name: string;
  context?: "shared";
  start: string;
  steps: Record<string, LoopStep>;
  permissions?: LoopPermission[];
  policies?: LoopPolicy[];
  hooks?: Record<LifecycleHook, HookAction[]>;
}

[
  {
    "agent": {
      "name": "backend-dev",
      "role": "Senior backend engineer",
      "model": "anthropic/claude-sonnet-4-5",
      "systemPrompt": "Focus on clean, tested TypeScript code.",
      "allowedTools": ["read", "write", "edit", "bash", "glob", "grep"],
      "assignedLoops": ["coding-flow"],
      "skills": ["api-security", "database-design"],
      "maxTurns": 200,
      "identity": {
        "displayName": "Alex Chen",
        "title": "Senior Backend Engineer",
        "tone": "Direct, technical",
        "responsibilities": [
          {
            "area": "API Development",
            "description": "Design and implement REST APIs",
            "priority": "critical"
          },
          "Code review",
          "Database schema design"
        ]
      }
    },
    "teamName": "engineering"
  }
]

interface VaultEntry {
  type: "smtp" | "imap" | "oauth" | "api_key" | "login" | "custom";
  label?: string;
  credentials: Record<string, string>;
}

interface Team {
  name: string;
  description?: string;
}