@agent-os-sdk/client 0.7.12 → 0.8.0

package/src/modules/presets.ts

@@ -0,0 +1,162 @@
+import type { RawClient } from "../client/raw.js";
+import { AgentsModule } from "./agents.js";
+import { TriggersModule } from "./triggers.js";
+
+export interface AgentTemplateConfig {
+  name: string;
+  trigger_type: "chatwoot" | "webhook" | "schedule";
+  output_type: "chatwoot" | "http";
+  llm?: {
+    credential_id?: string;
+    model?: string;
+    system_prompt?: string;
+  };
+  bindings?: Array<{
+    credential_id: string;
+    alias: string;
+  }>;
+}
+
+export interface CreatedAgentResult {
+  agent_id: string;
+  agent_name: string;
+  bundle_id?: string;
+  trigger_id?: string;
+  trigger_url?: string;
+  status: "live" | "draft";
+}
+
+const TRIGGER_TYPE_MAP: Record<string, { type: string; template_slug: string }> = {
+  chatwoot: { type: "webhook", template_slug: "chatwoot" },
+  webhook: { type: "webhook", template_slug: "generic" },
+  schedule: { type: "schedule", template_slug: "cron" },
+};
+
+const OUTPUT_NODE_MAP: Record<string, { kind: string; config: Record<string, unknown> }> = {
+  chatwoot: { kind: "output.chatwoot", config: {} },
+  http: { kind: "output.http", config: {} },
+};
+
+function generateGraphSpec(config: AgentTemplateConfig): Record<string, unknown> {
+  const triggerMapping = TRIGGER_TYPE_MAP[config.trigger_type] ?? TRIGGER_TYPE_MAP.webhook;
+  const outputMapping = OUTPUT_NODE_MAP[config.output_type] ?? OUTPUT_NODE_MAP.http;
+
+  // Safe validation (TS knows these keys exist in the constant, but runtime check is good practice)
+  if (!triggerMapping) throw new Error(`Invalid trigger type: ${config.trigger_type}`);
+  if (!outputMapping) throw new Error(`Invalid output type: ${config.output_type}`);
+
+  const nodes = [
+    {
+      id: "node-llm",
+      kind: "llm.chat",
+      label: "LLM",
+      config: {
+        model: config.llm?.model || "gpt-4o",
+        system_prompt: config.llm?.system_prompt || "You are a helpful assistant.",
+        ...(config.llm?.credential_id ? { credential_id: config.llm.credential_id } : {}),
+      },
+      ui: { x: 300, y: 200 },
+    },
+    {
+      id: "node-output",
+      ...outputMapping,
+      label: "Output",
+      ui: { x: 500, y: 200 },
+    },
+  ];
+
+  const edges = [
+    { from: "node-llm", to: "node-output" },
+  ];
+
+  const triggers = [
+    {
+      type: `${triggerMapping.template_slug}.${triggerMapping.type}`,
+      config: { events: ["message_created"] },
+    },
+  ];
+
+  return {
+    version: "1",
+    entrypoint: "node-llm",
+    nodes,
+    edges,
+    triggers,
+  };
+}
+
+export class PresetsModule {
+  private _client: RawClient;
+  private _headers: () => Record<string, string>;
+
+  // Internal modules needed for orchestration
+  private _agents: AgentsModule;
+  private _triggers: TriggersModule;
+
+  constructor(client: RawClient, getHeaders: () => Record<string, string>) {
+    this._client = client;
+    this._headers = getHeaders;
+    this._agents = new AgentsModule(client, getHeaders);
+    this._triggers = new TriggersModule(client, getHeaders);
+  }
+
+  async createAgent(config: AgentTemplateConfig): Promise<CreatedAgentResult | null> {
+    try {
+      console.log("[AgentOS SDK] Creating agent from preset...", {
+        name: config.name,
+        trigger_type: config.trigger_type,
+        output_type: config.output_type,
+      });
+
+      const { data: agent, error: createError } = await this._agents.create({ name: config.name });
+
+      if (createError || !agent) {
+        console.error("[AgentOS SDK] Failed to create agent:", createError);
+        return null;
+      }
+
+      const graphSpec = generateGraphSpec(config);
+
+      const { data: bundle, error: publishError } = await this._agents.publish(
+        agent.id,
+        graphSpec,
+        { set_as_live: true }
+      );
+
+      if (publishError) {
+        console.error("[AgentOS SDK] Failed to publish bundle:", publishError);
+        return {
+          agent_id: agent.id,
+          agent_name: agent.name,
+          status: "draft",
+        };
+      }
+
+      const triggerMapping = TRIGGER_TYPE_MAP[config.trigger_type] ?? TRIGGER_TYPE_MAP.webhook;
+      if (!triggerMapping) throw new Error("Trigger mapping failed");
+
+      const { data: trigger, error: triggerError } = await this._triggers.create({
+        name: `${config.name} - ${config.trigger_type}`,
+        agent_id: agent.id,
+        trigger_type: triggerMapping.type,
+        template_slug: triggerMapping.template_slug,
+      });
+
+      if (triggerError) {
+        console.warn("[AgentOS SDK] Failed to create trigger:", triggerError);
+      }
+
+      return {
+        agent_id: agent.id,
+        agent_name: agent.name,
+        bundle_id: bundle?.id,
+        trigger_id: trigger?.id,
+        trigger_url: (trigger as any)?.invoke_url,
+        status: "live",
+      };
+    } catch (err) {
+      console.error("[AgentOS SDK] Exception creating agent from preset:", err);
+      return null;
+    }
+  }
+}

package/src/modules/triggers.ts

@@ -150,6 +150,15 @@ export class TriggersModule {
 
     /**
      * Create a new trigger.
+     * @example
+     * ```ts
+     * const { data: trigger } = await client.triggers.create({
+     *   name: "My Webhook",
+     *   agent_id: "agent-uuid",
+     *   trigger_type: "webhook",
+     *   idempotency_key: "create-trigger-unique-key"
+     * });
+     * ```
      */
     async create(body: {
         name: string;
@@ -157,10 +166,20 @@ export class TriggersModule {
         trigger_type: string;
         template_slug?: string;
         config?: Record<string, unknown>;
+        /** Idempotency key for safe retries. When set, duplicate requests with the same key return 409 Conflict. */
+        idempotency_key?: string;
     }): Promise<APIResponse<Trigger>> {
+        const headers: Record<string, string> = { ...this.headers() };
+        if (body.idempotency_key) {
+            headers["X-Idempotency-Key"] = body.idempotency_key;
+        }
+
+        // Send body without idempotency_key (it's header-only)
+        const { idempotency_key, ...requestBody } = body;
+
         return this.client.POST<Trigger>("/v1/api/triggers", {
-            body,
-            headers: this.headers(),
+            body: requestBody,
+            headers,
         });
     }