@agent-os-sdk/client 0.7.12 → 0.7.13

package/src/modules/agents.ts

@@ -20,12 +20,17 @@ type AgentBundleSchema = components["schemas"]["AgentExportBundle"];
 export interface Agent {
     id: string;
     name: string;
-    description?: string;
     workspace_id: string;
     tenant_id: string;
     created_at: string;
     updated_at: string;
     live_bundle_id?: string | null;
+    // Dashboard fields (P1 fix)
+    status?: "live" | "draft";
+    has_draft?: boolean;
+    last_run_id?: string | null;
+    last_run_status?: string | null;
+    last_run_at?: string | null;
 }
 
 export interface AgentBundle extends AgentBundleSchema { }
@@ -87,35 +92,44 @@ export class AgentsModule {
 
     /**
      * Create a new agent.
+     * Backend only accepts `name` per CreateAgentRequest DTO.
      * @example
      * ```ts
-     * const { data: agent } = await client.agents.create({
-     *   name: "My Agent",
-     *   description: "Does cool stuff"
+     * const { data: agent } = await client.agents.create({ name: "My Agent" });
+     * 
+     * // With idempotency (safe to retry)
+     * const { data: agent } = await client.agents.create({ 
+     *   name: "My Agent", 
+     *   idempotency_key: "unique-key" 
      * });
      * ```
      */
     async create(body: {
         name: string;
-        description?: string;
-        graph_json?: unknown;
+        /** Idempotency key for safe retries. When set, duplicate requests with the same key return 409 Conflict. */
+        idempotency_key?: string;
     }): Promise<APIResponse<Agent>> {
+        const headers: Record<string, string> = { ...this.headers() };
+        if (body.idempotency_key) {
+            headers["X-Idempotency-Key"] = body.idempotency_key;
+        }
+
         return this.client.POST<Agent>("/v1/api/agents", {
-            body,
-            headers: this.headers(),
+            body: { name: body.name },
+            headers,
         });
     }
 
     /**
      * Update an existing agent.
+     * Uses PATCH per backend AgentsController.
      */
     async update(agentId: string, body: {
         name?: string;
-        description?: string;
         live_bundle_id?: string;
     }): Promise<APIResponse<Agent>> {
-        return this.client.PUT<Agent>("/v1/api/agents/{agentId}", {
-            params: { path: { agentId } },
+        return this.client.PATCH<Agent>("/v1/api/agents/{id}", {
+            params: { path: { id: agentId } },
             body,
             headers: this.headers(),
         });
@@ -184,14 +198,30 @@ export class AgentsModule {
      * Publish a new version (bundle) of the agent.
      * @param agentId The agent UUID
      * @param graph_spec The graph specification to publish
-     * @param options Optional settings: version_label for tagging, set_as_live to make this the active version
+     * @param options Optional settings: version_label for tagging, set_as_live to make this the active version, idempotency_key for safe retries
      * @returns Bundle response with version details
+     * @example
+     * ```ts
+     * const { data: bundle } = await client.agents.publish(agentId, graphSpec, {
+     *   idempotency_key: "publish-unique-key"
+     * });
+     * ```
      */
     async publish(
         agentId: string,
         graph_spec: Record<string, unknown>,
-        options?: { version_label?: string | null; set_as_live?: boolean }
+        options?: {
+            version_label?: string | null;
+            set_as_live?: boolean;
+            /** Idempotency key for safe retries */
+            idempotency_key?: string;
+        }
     ): Promise<APIResponse<components["schemas"]["BundleResponse"]>> {
+        const headers: Record<string, string> = { ...this.headers() };
+        if (options?.idempotency_key) {
+            headers["X-Idempotency-Key"] = options.idempotency_key;
+        }
+
         return this.client.POST<components["schemas"]["BundleResponse"]>("/v1/api/agents/{id}/publish", {
             params: { path: { id: agentId } },
             body: {
@@ -199,7 +229,7 @@ export class AgentsModule {
                 version_label: options?.version_label ?? null,
                 set_as_live: options?.set_as_live ?? true
             },
-            headers: this.headers()
+            headers
         });
     }
 

package/src/modules/credentials.ts

@@ -99,6 +99,7 @@ export class CredentialsModule {
 
     /**
      * Update a credential.
+     * Uses PATCH per backend CredentialsController.
      */
     async update(credentialId: string, body: {
         name?: string;
@@ -106,7 +107,7 @@ export class CredentialsModule {
         status?: string;
         sharing_mode?: string;
     }): Promise<APIResponse<Credential>> {
-        return this.client.PUT<Credential>("/v1/api/credentials/{id}", {
+        return this.client.PATCH<Credential>("/v1/api/credentials/{id}", {
             params: { path: { id: credentialId } },
             body,
             headers: this.headers(),

package/src/modules/crons.ts

@@ -79,13 +79,14 @@ export class CronsModule {
 
     /**
      * Update a cron job.
+     * Uses PATCH per backend CronsController.
      */
     async update(cronId: string, body: {
         schedule?: string;
         enabled?: boolean;
         input?: unknown;
     }): Promise<APIResponse<CronJob>> {
-        return this.client.PUT<CronJob>("/v1/api/crons/{id}", {
+        return this.client.PATCH<CronJob>("/v1/api/crons/{id}", {
             params: { path: { id: cronId } },
             body,
             headers: this.headers(),

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,
         });
     }