@imbrace/cli 0.4.0 → 0.5.0

package/dist/commands/guardrail/delete.js

@@ -0,0 +1,41 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { confirm, input } from "@inquirer/prompts";
+import { getClient } from "../../lib/client.js";
+export default class GuardrailDelete extends BaseCommand {
+    static description = "Delete a Guardrail. Any AI agent attached via --guardrail-id will lose its safety rules.";
+    static examples = [
+        "imbrace guardrail delete <id> --yes --json",
+    ];
+    static args = {
+        id: Args.string({ description: "Guardrail ID" }),
+    };
+    static flags = {
+        yes: Flags.boolean({ char: "y", description: "Skip confirmation" }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(GuardrailDelete);
+        const id = args.id ?? (flags.json ? this.error("ID is required") : await input({ message: "Guardrail ID:" }));
+        if (!flags.yes) {
+            const ok = await confirm({ message: `Delete guardrail ${id}?`, default: false });
+            if (!ok) {
+                this.log("Cancelled.");
+                return;
+            }
+        }
+        try {
+            const client = getClient();
+            await client.ai.deleteGuardrail(id);
+            const message = "Guardrail deleted";
+            if (flags.json) {
+                this.log(JSON.stringify({ ok: true, message }, null, 2));
+                return;
+            }
+            this.log(`\n✅ ${message}\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/guardrail/get.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../base-command.js";
+export default class GuardrailGet extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/guardrail/get.js

@@ -0,0 +1,42 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { input } from "@inquirer/prompts";
+import { getClient } from "../../lib/client.js";
+export default class GuardrailGet extends BaseCommand {
+    static description = "Get details of a single guardrail";
+    static examples = [
+        "imbrace guardrail get <guardrailId>",
+        "imbrace guardrail get <guardrailId> --json",
+    ];
+    static args = {
+        id: Args.string({ description: "Guardrail ID" }),
+    };
+    static flags = {
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(GuardrailGet);
+        const id = args.id ?? (flags.json ? this.error("ID is required") : await input({ message: "Guardrail ID:" }));
+        try {
+            const client = getClient();
+            const data = await client.ai.getGuardrail(id);
+            if (flags.json) {
+                this.log(JSON.stringify({ ok: true, data }, null, 2));
+                return;
+            }
+            this.log(`\n  ID:                ${data.guardrails_config_id || data._id || ""}`);
+            this.log(`  Name:              ${data.name || ""}`);
+            this.log(`  Model:             ${data.model || ""}`);
+            this.log(`  Provider ID:       ${data.guardrail_provider_id || ""}`);
+            this.log(`  Description:       ${(data.description || "").slice(0, 80)}`);
+            if (data.unsafe_categories)
+                this.log(`  Unsafe categories: ${(data.unsafe_categories || []).join(", ") || "(none)"}`);
+            if (data.competitor_keywords)
+                this.log(`  Competitors:       ${(data.competitor_keywords || []).join(", ") || "(none)"}`);
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/guardrail/list.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from "../../base-command.js";
+export default class GuardrailList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/guardrail/list.js

@@ -0,0 +1,40 @@
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { getClient } from "../../lib/client.js";
+export default class GuardrailList extends BaseCommand {
+    static description = "List Guardrails (safety rules + compliance constraints attached to AI agents via --guardrail-id)";
+    static examples = [
+        "imbrace guardrail list",
+        "imbrace guardrail list --json",
+    ];
+    static flags = {
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { flags } = await this.parse(GuardrailList);
+        try {
+            const client = getClient();
+            const res = await client.ai.listGuardrails();
+            // Backend returns a raw array, not { data, total }.
+            const data = Array.isArray(res) ? res : (res?.data ?? []);
+            if (flags.json) {
+                this.log(JSON.stringify({ ok: true, count: data.length, data }, null, 2));
+                return;
+            }
+            this.log(`\n  Found ${data.length} guardrail(s):\n`);
+            this.log("  ID                                    NAME                          MODEL");
+            this.log("  ──────────────────────────────────────────────────────────────────────────────");
+            for (const g of data) {
+                // Backend's id field is `guardrails_config_id`, not `_id`.
+                const id = (g.guardrails_config_id || g._id || "").padEnd(38);
+                const name = (g.name || "").padEnd(28);
+                const model = g.model || "";
+                this.log(`  ${id}  ${name}  ${model}`);
+            }
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/guardrail/update.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from "../../base-command.js";
+export default class GuardrailUpdate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        model: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        instructions: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "guardrail-provider-id": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "unsafe-categories": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "custom-unsafe-patterns": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "competitor-keywords": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/guardrail/update.js

@@ -0,0 +1,49 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { getClient } from "../../lib/client.js";
+export default class GuardrailUpdate extends BaseCommand {
+    static description = "Update a Guardrail (PUT — must pass name, model, instructions; other fields optional)";
+    static examples = [
+        'imbrace guardrail update <id> --name "X" --model gpt-4o --instructions "..." --json',
+    ];
+    static args = {
+        id: Args.string({ description: "Guardrail ID", required: true }),
+    };
+    static flags = {
+        name: Flags.string({ char: "n", description: "Name (required by SDK PUT)", required: true }),
+        model: Flags.string({ description: "LLM model (required by SDK PUT)", required: true }),
+        instructions: Flags.string({ char: "i", description: "Rules (required by SDK PUT)", required: true }),
+        "guardrail-provider-id": Flags.string({ description: "Guardrail provider UUID" }),
+        description: Flags.string({ char: "d", description: "Human-readable description" }),
+        "unsafe-categories": Flags.string({ description: "Comma-separated unsafe categories" }),
+        "custom-unsafe-patterns": Flags.string({ description: "Comma-separated custom regex patterns" }),
+        "competitor-keywords": Flags.string({ description: "Comma-separated competitor names" }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(GuardrailUpdate);
+        const split = (s) => s.split(",").map((x) => x.trim()).filter(Boolean);
+        try {
+            const client = getClient();
+            const data = await client.ai.updateGuardrail(args.id, {
+                name: flags.name,
+                model: flags.model,
+                instructions: flags.instructions,
+                ...(flags["guardrail-provider-id"] && { guardrail_provider_id: flags["guardrail-provider-id"] }),
+                ...(flags.description && { description: flags.description }),
+                ...(flags["unsafe-categories"] && { unsafe_categories: split(flags["unsafe-categories"]) }),
+                ...(flags["custom-unsafe-patterns"] && { custom_unsafe_patterns: split(flags["custom-unsafe-patterns"]) }),
+                ...(flags["competitor-keywords"] && { competitor_keywords: split(flags["competitor-keywords"]) }),
+            });
+            const message = "Guardrail updated";
+            if (flags.json) {
+                this.log(JSON.stringify({ ok: true, message, data }, null, 2));
+                return;
+            }
+            this.log(`\n✅ ${message}\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/orchestrator/create.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from "../../base-command.js";
+export default class OrchestratorCreate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        instructions: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        model: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "provider-id": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "sub-agents": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "team-leads": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        temperature: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "id-only": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/orchestrator/create.js

@@ -0,0 +1,68 @@
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { input } from "@inquirer/prompts";
+import { createAgent, patchOrchestratorFields } from "../../lib/ai-agent.js";
+export default class OrchestratorCreate extends BaseCommand {
+    static description = "Create an Orchestrator agent (coordinates multiple sub-agents toward a shared goal)";
+    static examples = [
+        'imbrace orchestrator create --name "Sales Orchestrator" --instructions "Route requests to the right sub-agent" --sub-agents uc_xxx,uc_yyy --json',
+        'imbrace orchestrator create --name "Support Lead" --team-leads uc_zzz --id-only',
+    ];
+    static flags = {
+        name: Flags.string({ char: "n", description: "Orchestrator name" }),
+        description: Flags.string({ char: "d", description: "Description" }),
+        instructions: Flags.string({ char: "i", description: "Routing / coordination instructions" }),
+        model: Flags.string({ description: "LLM model (e.g. gpt-4o)" }),
+        "provider-id": Flags.string({ description: "LLM provider ID. Default 'system'." }),
+        "sub-agents": Flags.string({ description: "Comma-separated sub-agent IDs (the agents this orchestrator delegates to)" }),
+        "team-leads": Flags.string({ description: "Comma-separated team-lead IDs" }),
+        temperature: Flags.string({ description: "Model temperature 0.0-2.0 (default: 0.1)" }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+        "id-only": Flags.boolean({ description: "Print only the new orchestrator ID" }),
+    };
+    async run() {
+        const { flags } = await this.parse(OrchestratorCreate);
+        const nonInteractive = flags.json || flags["id-only"];
+        const name = flags.name ?? (nonInteractive ? this.error("--name is required with --json or --id-only") : await input({ message: "Orchestrator name:" }));
+        const instructions = flags.instructions ?? (nonInteractive ? undefined : await input({ message: "Instructions (optional):", default: "" }));
+        const body = {
+            name,
+            ...(instructions && { instructions }),
+            ...(flags.description && { description: flags.description }),
+            ...(flags.model && { model: flags.model }),
+            ...(flags["provider-id"] && { provider_id: flags["provider-id"] }),
+            ...(flags.temperature && { temperature: parseFloat(flags.temperature) }),
+            is_orchestrator: true,
+            sub_agents: flags["sub-agents"] ? flags["sub-agents"].split(",").map(s => s.trim()).filter(Boolean) : [],
+            team_leads: flags["team-leads"] ? flags["team-leads"].split(",").map(s => s.trim()).filter(Boolean) : [],
+        };
+        try {
+            const data = await createAgent(body);
+            const useCaseId = data?._id ?? "";
+            // createUseCase ignores sub_agents/team_leads on the assistant block.
+            // Patch them in via chatAi.updateAiAgent after the agent record exists.
+            if (useCaseId && (body.sub_agents.length || body.team_leads.length)) {
+                await patchOrchestratorFields(useCaseId, {
+                    sub_agents: body.sub_agents,
+                    team_leads: body.team_leads,
+                });
+            }
+            const message = `Orchestrator "${name}" created`;
+            if (flags["id-only"]) {
+                this.log(data?._id ?? "");
+                return;
+            }
+            if (flags.json) {
+                this.log(JSON.stringify({ ok: true, message, data }, null, 2));
+                return;
+            }
+            this.log(`\n✅ ${message}`);
+            if (data?._id)
+                this.log(`   ID: ${data._id}`);
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/orchestrator/delete.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from "../../base-command.js";
+export default class OrchestratorDelete extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/orchestrator/delete.js

@@ -0,0 +1,41 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { confirm, input } from "@inquirer/prompts";
+import { getClient } from "../../lib/client.js";
+export default class OrchestratorDelete extends BaseCommand {
+    static description = "Delete an Orchestrator agent";
+    static examples = [
+        "imbrace orchestrator delete <id> --yes --json",
+    ];
+    static args = {
+        id: Args.string({ description: "Orchestrator ID" }),
+    };
+    static flags = {
+        yes: Flags.boolean({ char: "y", description: "Skip confirmation" }),
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(OrchestratorDelete);
+        const id = args.id ?? (flags.json ? this.error("ID is required") : await input({ message: "Orchestrator ID:" }));
+        if (!flags.yes) {
+            const ok = await confirm({ message: `Delete orchestrator ${id}?`, default: false });
+            if (!ok) {
+                this.log("Cancelled.");
+                return;
+            }
+        }
+        try {
+            const client = getClient();
+            await client.agent.delete(id);
+            const message = "Orchestrator deleted";
+            if (flags.json) {
+                this.log(JSON.stringify({ ok: true, message }, null, 2));
+                return;
+            }
+            this.log(`\n✅ ${message}\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/orchestrator/get.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../base-command.js";
+export default class OrchestratorGet extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/orchestrator/get.js

@@ -0,0 +1,52 @@
+import { Args, Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { input } from "@inquirer/prompts";
+import { getClient } from "../../lib/client.js";
+import { gatewayFetch } from "../../lib/gateway.js";
+export default class OrchestratorGet extends BaseCommand {
+    static description = "Get details of an Orchestrator agent (sub_agents, team_leads, instructions)";
+    static examples = [
+        "imbrace orchestrator get <id>",
+        "imbrace orchestrator get <id> --json",
+    ];
+    static args = {
+        id: Args.string({ description: "Orchestrator ID" }),
+    };
+    static flags = {
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(OrchestratorGet);
+        const id = args.id ?? (flags.json ? this.error("ID is required") : await input({ message: "Orchestrator ID:" }));
+        try {
+            const client = getClient();
+            const tpl = (await client.agent.get(id))?.data ?? {};
+            // sub_agents / team_leads live on the assistant, not the use case.
+            // Fetch the assistant directly to get the canonical state.
+            const assistant = tpl.assistant_id
+                ? await gatewayFetch(`/v3/ai/assistants/${tpl.assistant_id}`).catch(() => null)
+                : null;
+            if (flags.json) {
+                this.log(JSON.stringify({ ok: true, data: { ...tpl, assistant } }, null, 2));
+                return;
+            }
+            const agentType = assistant?.agent_type ?? tpl.agent_type;
+            this.log(`\n  ID:               ${tpl._id || tpl.id || ""}`);
+            this.log(`  Title:            ${tpl.title || tpl.name || ""}`);
+            this.log(`  Assistant ID:     ${tpl.assistant_id || ""}`);
+            this.log(`  Agent type:       ${agentType || ""}`);
+            this.log(`  Is orchestrator:  ${agentType === "team_lead"}`);
+            const subs = assistant?.sub_agents || [];
+            const leads = assistant?.team_leads || [];
+            // Backend returns either a string id or an enriched object {assistant_id, name}.
+            const fmt = (a) => typeof a === "string" ? a : (a?.name || a?.assistant_id || JSON.stringify(a));
+            this.log(`  Sub-agents (${subs.length}): ${subs.map(fmt).join(", ") || "(none)"}`);
+            this.log(`  Team-leads (${leads.length}): ${leads.map(fmt).join(", ") || "(none)"}`);
+            this.log(`  Description:      ${(tpl.short_description || "").slice(0, 80)}`);
+            this.log("");
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/commands/orchestrator/list.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from "../../base-command.js";
+export default class OrchestratorList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/orchestrator/list.js

@@ -0,0 +1,41 @@
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+import { getClient } from "../../lib/client.js";
+export default class OrchestratorList extends BaseCommand {
+    static description = "List Orchestrator agents (filters AI Agents where is_orchestrator=true)";
+    static examples = [
+        "imbrace orchestrator list",
+        "imbrace orchestrator list --json",
+    ];
+    static flags = {
+        json: Flags.boolean({ description: "Output as JSON" }),
+    };
+    async run() {
+        const { flags } = await this.parse(OrchestratorList);
+        try {
+            const client = getClient();
+            const res = await client.agent.list();
+            const all = (res?.data ?? res ?? []);
+            // Webapp identifies orchestrators via agent_type === "team_lead"
+            // (see new-frontend/.../useAIAssistantFormHook.tsx). Filter client-side.
+            const data = all.filter((a) => a.agent_type === "team_lead" ||
+                a.assistant?.agent_type === "team_lead");
+            if (flags.json) {
+                this.log(JSON.stringify({ ok: true, count: data.length, data }, null, 2));
+                return;
+            }
+            this.log(`\n  Found ${data.length} orchestrator(s):\n`);
+            this.log("  ID                                    TITLE");
+            this.log("  ────────────────────────────────────────────────────────────");
+            for (const a of data) {
+                const id = (a._id || a.id || "").padEnd(38);
+                const title = a.title || a.name || "";
+                this.log(`  ${id}  ${title}`);
+            }
+            this.log(`\n  Use 'imbrace orchestrator get <id>' to see sub_agents.\n`);
+        }
+        catch (error) {
+            this.error(`Failed: ${error.message}`);
+        }
+    }
+}

package/dist/lib/ai-agent.d.ts

@@ -6,6 +6,7 @@ export interface CreateAgentInput {
     model?: string;
     provider_id?: string;
     mode?: string;
+    agent_type?: string;
     channel?: string;
     category?: string[] | string;
     personality_role?: string;
@@ -24,9 +25,16 @@ export interface CreateAgentInput {
     default_folder_id?: string;
     board_ids?: string[];
     file_ids?: string[];
+    is_orchestrator?: boolean;
+    sub_agents?: string[];
+    team_leads?: string[];
 }
 export declare function createAgent(body: CreateAgentInput): Promise<any>;
 export declare function updateAgent(id: string, body: Record<string, any>): Promise<any>;
+export declare function patchOrchestratorFields(useCaseId: string, patch: {
+    sub_agents?: string[];
+    team_leads?: string[];
+}): Promise<void>;
 export declare function listProviders(): Promise<{
     id: any;
     _id: any;

package/dist/lib/ai-agent.js

@@ -6,11 +6,18 @@ export async function createAgent(body) {
     const client = getClient();
     const slug = body.name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
     const workflowName = `${slug}_v${Date.now()}`;
+    // Orchestrator detection: webapp encodes orchestrator-ness via
+    // `agent_type: "team_lead"`, not via a separate `is_orchestrator` field.
+    // (See new-frontend/src/pages/AIAssistantManagement/useAIAssistantFormHook.tsx:
+    // `is_orchestrator: responseData.agent_type === agentTypeValue.teamLead`.)
+    const agentType = body.is_orchestrator || body.agent_type === "team_lead"
+        ? "team_lead"
+        : (body.agent_type || "agent");
     const data = await client.agent.createUseCase({
         usecase: {
             title: body.name,
             short_description: body.description || "",
-            agent_type: "agent",
+            agent_type: agentType,
             demo_url: "https://chat-widgetv2.imbrace.co",
             supported_channels: [{ title: "channel_", icon: "" }],
         },
@@ -22,7 +29,7 @@ export async function createAgent(body) {
             credential_name: `${body.mode || "standard"} | ${body.name}`,
             provider_id: body.provider_id || "system",
             model_id: body.model || "Default",
-            agent_type: "agent",
+            agent_type: agentType,
             mode: body.mode || "standard",
             version: 2,
             channel: body.channel || "",
@@ -44,8 +51,9 @@ export async function createAgent(body) {
             board_ids: body.board_ids || [],
             file_ids: body.file_ids || [],
             workflow_function_call: [],
-            sub_agents: [],
-            team_leads: [],
+            sub_agents: body.sub_agents || [],
+            team_leads: body.team_leads || [],
+            is_orchestrator: body.is_orchestrator ?? false,
             metadata: {
                 other_requirements: [],
                 channel_id: "",
@@ -76,7 +84,7 @@ export async function updateAgent(id, body) {
         typeof body.show_thinking_process === "boolean" || body.mode ||
         ASSISTANT_FIELDS.some((f) => body[f] !== undefined));
     if (hasAssistantUpdate) {
-        // chatAi.updateAssistant uses PUT (full replace) — fetch+merge so unchanged
+        // chatAi.updateAiAgent uses PUT (full replace) — fetch+merge so unchanged
         // fields aren't reset to null.
         const currentAssistant = await gatewayFetch(`/v3/ai/assistants/${assistantId}`);
         const aUpdate = {
@@ -101,7 +109,7 @@ export async function updateAgent(id, body) {
             if (body[f] !== undefined)
                 aUpdate[f] = body[f];
         }
-        results.assistant = await client.chatAi.updateAssistant(assistantId, aUpdate);
+        results.assistant = await client.chatAi.updateAiAgent(assistantId, aUpdate);
     }
     if (body.name || body.description) {
         const tUpdate = {};
@@ -116,6 +124,55 @@ export async function updateAgent(id, body) {
     }
     return results;
 }
+// Resolve a list of agent identifiers (mix of UseCase IDs `uc_xxx` and bare
+// assistant UUIDs) into their assistant_id form. The orchestrator backend
+// stores `sub_agents` as assistant IDs, NOT use-case IDs.
+async function resolveAssistantIds(ids) {
+    const client = getClient();
+    const out = [];
+    for (const id of ids) {
+        if (!id)
+            continue;
+        if (id.startsWith("uc_")) {
+            try {
+                const tpl = (await client.agent.get(id))?.data ?? {};
+                if (tpl.assistant_id)
+                    out.push(tpl.assistant_id);
+            }
+            catch {
+                // Unknown UseCase — skip with no error so partial input still works.
+            }
+        }
+        else {
+            out.push(id);
+        }
+    }
+    return out;
+}
+// For orchestrators: createUseCase ignores `sub_agents` / `team_leads` /
+// `agent_type=team_lead` fields on the assistant block. We work around by
+// following up with a chatAi.updateAiAgent PUT once the use case + assistant
+// exist. Backend stores them as assistant IDs (UUIDs), so we resolve any
+// `uc_*` use-case IDs into assistant IDs first.
+export async function patchOrchestratorFields(useCaseId, patch) {
+    const client = getClient();
+    const tpl = (await client.agent.get(useCaseId))?.data ?? {};
+    const assistantId = tpl.assistant_id;
+    if (!assistantId)
+        return;
+    const subAgentAssistantIds = patch.sub_agents
+        ? await resolveAssistantIds(patch.sub_agents)
+        : undefined;
+    const teamLeadAssistantIds = patch.team_leads
+        ? await resolveAssistantIds(patch.team_leads)
+        : undefined;
+    const current = await gatewayFetch(`/v3/ai/assistants/${assistantId}`);
+    await client.chatAi.updateAiAgent(assistantId, {
+        ...current,
+        ...(subAgentAssistantIds && { sub_agents: subAgentAssistantIds }),
+        ...(teamLeadAssistantIds && { team_leads: teamLeadAssistantIds }),
+    });
+}
 export async function listProviders() {
     const client = getClient();
     const [r, systemModels] = await Promise.all([