@agent-os-sdk/client 0.9.2 → 0.9.3

package/src/index.ts

@@ -96,6 +96,7 @@ export type { SSEEvent, SSEOptions } from "./sse/client.js";
 
 export * from "./modules/agents.js";
 export * from "./modules/auth.js";
+export * from "./modules/chatwoot.js";
 export * from "./modules/credentials.js";
 export * from "./modules/me.js";
 export * from "./modules/members.js";

package/src/modules/agents.ts

@@ -7,8 +7,8 @@
  * - create*, update*, delete* for mutations
  */
 
-import type { RawClient, APIResponse, components } from "../client/raw.js";
-import type { PaginationParams, PaginatedResponse } from "../client/helpers.js";
+import type { PaginatedResponse, PaginationParams } from "../client/helpers.js";
+import type { APIResponse, components, RawClient } from "../client/raw.js";
 
 // Type aliases for this module
 
@@ -31,6 +31,7 @@ export interface Agent {
     last_run_id?: string | null;
     last_run_status?: string | null;
     last_run_at?: string | null;
+    metadata?: any | null;
 }
 
 export interface AgentBundle extends AgentBundleSchema { }
@@ -106,6 +107,7 @@ export class AgentsModule {
      */
     async create(body: {
         name: string;
+        metadata?: any | null;
         /** Idempotency key for safe retries. When set, duplicate requests with the same key return 409 Conflict. */
         idempotency_key?: string;
     }): Promise<APIResponse<Agent>> {
@@ -115,7 +117,10 @@ export class AgentsModule {
         }
 
         return this.client.POST<Agent>("/v1/api/agents", {
-            body: { name: body.name },
+            body: {
+                name: body.name,
+                metadata: body.metadata
+            },
             headers,
         });
     }
@@ -127,6 +132,7 @@ export class AgentsModule {
     async update(agentId: string, body: {
         name?: string;
         live_bundle_id?: string;
+        metadata?: any | null;
     }): Promise<APIResponse<Agent>> {
         return this.client.PATCH<Agent>("/v1/api/agents/{id}", {
             params: { path: { id: agentId } },

package/src/modules/chatwoot.ts

@@ -0,0 +1,242 @@
+/**
+ * Chatwoot Module
+ */
+
+import type { APIResponse, RawClient } from "../client/raw.js";
+
+export interface ChatwootInboxUrlResponse {
+  url: string;
+}
+
+export interface ChatwootConfig {
+  baseUrl: string;
+  accountId: string;
+  apiAccessToken: string;
+}
+
+export class ChatwootModule {
+  constructor(
+    private client: RawClient,
+    private headers: () => Record<string, string>
+  ) { }
+
+  /**
+   * Internal helper to resolve Chatwoot configuration from AgentOS credentials
+   */
+  private async _getChatwootConfig(credentialId: string): Promise<{ data: ChatwootConfig | undefined; error: any; response?: Response }> {
+    const { data: credential, error } = await this.client.GET<any>("/v1/api/credentials/{id}", {
+      params: {
+        path: { id: credentialId },
+        query: { includeValues: true }
+      },
+      headers: this.headers(),
+    });
+
+    if (error || !credential) {
+      return { error: error || { message: "Credential not found", code: "CREDENTIAL_NOT_FOUND" }, data: undefined };
+    }
+
+    // Backend now returns 'values' when includeValues=true
+    const values = credential.values || credential.Values || {};
+    const publicConfig = credential.publicConfig || credential.PublicConfig || {};
+    const data = credential.data || {};
+
+    const url = publicConfig.url || data.url || values.url || publicConfig.endpoint || data.endpoint || values.endpoint || values.base_url;
+    let accountId = publicConfig.account_id || data.account_id || values.account_id || publicConfig.accountId || data.accountId || values.accountId;
+    const apiAccessToken = values.api_access_token || data.api_access_token || values.api_key || data.api_key || values.apiKey || data.apiKey || values.api_token;
+
+    if (!url || !apiAccessToken) {
+      return { error: { message: "Invalid Chatwoot credential: missing URL/Endpoint or API Access Token/Key", code: "INVALID_CREDENTIAL" }, data: undefined };
+    }
+
+    const baseUrl = url.endsWith("/") ? url.slice(0, -1) : url;
+
+    // Auto-discover accountId if missing
+    if (!accountId) {
+      try {
+        const profileRes = await fetch(`${baseUrl}/api/v1/profile`, {
+          headers: { "api_access_token": apiAccessToken }
+        });
+        if (profileRes.ok) {
+          const profile = await profileRes.json();
+          // Use the first available account
+          if (profile.accounts && profile.accounts.length > 0) {
+            accountId = profile.accounts[0].id;
+          }
+        }
+      } catch (err) {
+        console.warn("Failed to auto-discover Chatwoot account ID:", err);
+      }
+    }
+
+    if (!accountId) {
+      return { error: { message: "Invalid Chatwoot credential: missing Account ID and auto-discovery failed.", code: "ACCOUNT_ID_MISSING" }, data: undefined };
+    }
+
+    return {
+      data: {
+        baseUrl,
+        accountId: String(accountId),
+        apiAccessToken
+      },
+      error: null
+    };
+  }
+
+  /**
+   * Direct call to Chatwoot API
+   */
+  private async _chatwootRequest(config: ChatwootConfig, method: string, path: string, body?: any): Promise<APIResponse<any>> {
+    const url = `${config.baseUrl}${path}`;
+    const headers = {
+      "api_access_token": config.apiAccessToken,
+      "Content-Type": "application/json",
+    };
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+      });
+
+      let data = null;
+      const contentType = response.headers.get("content-type");
+      if (contentType && contentType.includes("application/json")) {
+        try {
+          const text = await response.text();
+          if (text) data = JSON.parse(text);
+        } catch (e) {
+          // Ignore JSON parse errors for empty bodies
+        }
+      }
+
+      if (!response.ok) {
+        return { error: data || { message: `Chatwoot API error: ${response.statusText}`, code: "API_ERROR" }, data: undefined, response };
+      }
+
+      return { data, error: undefined, response };
+    } catch (err) {
+      return { error: { message: (err as Error).message, code: "UNKNOWN_ERROR" }, data: undefined, response: new Response() };
+    }
+  }
+
+  /**
+   * Get the inbox URL for a specific credential.
+   * Use this to open the Chatwoot inbox directly.
+   */
+  async getInboxUrl(credentialId: string): Promise<APIResponse<ChatwootInboxUrlResponse>> {
+    const { data: config, error } = await this._getChatwootConfig(credentialId);
+
+    if (error || !config) {
+      return { error: error || { message: "Config not found", code: "CONFIG_MISSING" }, data: undefined, response: new Response() };
+    }
+
+    const inboxUrl = `${config.baseUrl}/app/accounts/${config.accountId}/inbox`;
+
+    return {
+      data: { url: inboxUrl },
+      error: undefined,
+      response: new Response(),
+    };
+  }
+
+  /**
+   * List all inboxes
+   */
+  async listInboxes(credentialId: string): Promise<APIResponse<any[]>> {
+    const { data: config, error } = await this._getChatwootConfig(credentialId);
+    if (error || !config) return { error: error || { message: "Config not found", code: "CONFIG_MISSING" }, data: undefined, response: new Response() };
+
+    const res = await this._chatwootRequest(config, "GET", `/api/v1/accounts/${config.accountId}/inboxes`);
+
+    // Chatwoot API returns { payload: [...] }
+    if (res.data && Array.isArray(res.data.payload)) {
+      return { data: res.data.payload, error: undefined, response: res.response };
+    }
+
+    return res;
+  }
+
+  /**
+   * Create a new inbox
+   */
+  async createInbox(credentialId: string, data: any): Promise<APIResponse<any>> {
+    const { data: config, error } = await this._getChatwootConfig(credentialId);
+    if (error || !config) return { error: error || { message: "Config not found", code: "CONFIG_MISSING" }, data: undefined, response: new Response() };
+
+    return this._chatwootRequest(config, "POST", `/api/v1/accounts/${config.accountId}/inboxes`, data);
+  }
+
+  /**
+   * Get a specific inbox
+   */
+  async getInbox(credentialId: string, inboxId: string | number): Promise<APIResponse<any>> {
+    const { data: config, error } = await this._getChatwootConfig(credentialId);
+    if (error || !config) return { error: error || { message: "Config not found", code: "CONFIG_MISSING" }, data: undefined, response: new Response() };
+
+    return this._chatwootRequest(config, "GET", `/api/v1/accounts/${config.accountId}/inboxes/${inboxId}`);
+  }
+
+  /**
+   * Update an inbox
+   */
+  async updateInbox(credentialId: string, inboxId: string | number, data: any): Promise<APIResponse<any>> {
+    const { data: config, error } = await this._getChatwootConfig(credentialId);
+    if (error || !config) return { error: error || { message: "Config not found", code: "CONFIG_MISSING" }, data: undefined, response: new Response() };
+
+    return this._chatwootRequest(config, "PATCH", `/api/v1/accounts/${config.accountId}/inboxes/${inboxId}`, data);
+  }
+
+  /**
+   * Delete an inbox
+   */
+  async deleteInbox(credentialId: string, inboxId: string | number): Promise<APIResponse<any>> {
+    const { data: config, error } = await this._getChatwootConfig(credentialId);
+    if (error || !config) return { error: error || { message: "Config not found", code: "CONFIG_MISSING" }, data: undefined, response: new Response() };
+
+    return this._chatwootRequest(config, "DELETE", `/api/v1/accounts/${config.accountId}/inboxes/${inboxId}`);
+  }
+
+  /**
+   * Get inbox metrics
+   */
+  async getInboxMetrics(credentialId: string, inboxId: string | number): Promise<APIResponse<any>> {
+    const { data: config, error } = await this._getChatwootConfig(credentialId);
+    if (error || !config) return { error: error || { message: "Config not found", code: "CONFIG_MISSING" }, data: undefined, response: new Response() };
+
+    return this._chatwootRequest(config, "GET", `/api/v1/accounts/${config.accountId}/inboxes/${inboxId}/metrics`);
+  }
+
+  /**
+   * Get the inbox URL for a specific agent.
+   */
+  async getAgentInboxUrl(agentId: string): Promise<APIResponse<ChatwootInboxUrlResponse>> {
+    const { data: triggers, error: triggerError } = await this.client.GET<any>("/v1/api/triggers", {
+      params: { query: { agent_id: agentId } },
+      headers: this.headers(),
+    });
+
+    if (triggerError || !triggers) {
+      return { error: triggerError || { message: "Failed to fetch triggers", code: "TRIGGER_FETCH_FAILED" }, data: undefined, response: new Response() };
+    }
+
+    const chatwootTrigger = triggers.items?.find((t: any) =>
+      t.type === "chatwoot" ||
+      (t.type === "evolution_whatsapp" && t.config?.chat_platform === "chatwoot") ||
+      (t.config?.credential_id && (t.type === "chatwoot" || t.type.includes("whatsapp")))
+    );
+
+    if (!chatwootTrigger) {
+      return { error: { message: "No compatible trigger found for this agent", code: "NO_TRIGGER" }, data: undefined, response: new Response() };
+    }
+
+    const credentialId = chatwootTrigger.config?.credential_id;
+
+    if (!credentialId) {
+      return { error: { message: "Trigger configuration missing credential_id", code: "MISSING_CREDENTIAL_ID" }, data: undefined, response: new Response() };
+    }
+
+    return this.getInboxUrl(credentialId);
+  }
+}

package/src/modules/credentials.ts

@@ -68,9 +68,12 @@ export class CredentialsModule {
     /**
      * Get a credential by ID.
      */
-    async get(credentialId: string): Promise<APIResponse<Credential>> {
+    async get(credentialId: string, includeValues: boolean = false): Promise<APIResponse<Credential>> {
         return this.client.GET<Credential>("/v1/api/credentials/{id}", {
-            params: { path: { id: credentialId } },
+            params: {
+                path: { id: credentialId },
+                query: { includeValues }
+            },
             headers: this.headers(),
         });
     }
@@ -142,4 +145,14 @@ export class CredentialsModule {
             headers: this.headers(),
         });
     }
+
+    /**
+     * List available models for a credential provider.
+     */
+    async listModels(credentialId: string): Promise<APIResponse<string[]>> {
+        return this.client.GET<string[]>("/v1/api/credentials/{id}/models", {
+            params: { path: { id: credentialId } },
+            headers: this.headers(),
+        });
+    }
 }