@agent-os-sdk/client 0.9.26 → 0.9.28

package/src/modules/chatwoot.ts

@@ -1,242 +0,0 @@
-/**
- * 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/checkpoints.ts

@@ -1,87 +0,0 @@
-/**
- * Checkpoints Module - Fully Typed
- */
-
-import type { RawClient, APIResponse, components } from "../client/raw.js";
-
-type CheckpointDetail = components["schemas"]["CheckpointDetail"];
-type CheckpointListResponse = components["schemas"]["CheckpointListResponse"];
-
-export interface Checkpoint {
-    id: string;
-    run_id: string;
-    thread_id: string;
-    step_name: string;
-    checkpoint_id: string;
-    parent_checkpoint_id?: string;
-    has_state_snapshot: boolean;
-    created_at: string;
-}
-
-export interface CheckpointNode {
-    id: string;
-    step_name: string;
-    checkpoint_id: string;
-    parent_checkpoint_id?: string;
-    created_at: string;
-    children?: CheckpointNode[];
-}
-
-export interface CheckpointsResponse {
-    run_id: string;
-    total_checkpoints: number;
-    checkpoints: CheckpointNode[];
-}
-
-export interface ReplayResponse {
-    run_id: string;
-    status: string;
-    replayed_from_checkpoint_id: string;
-}
-
-export class CheckpointsModule {
-    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
-
-    /**
-     * List checkpoints for a run.
-     * @param workspaceId - Workspace ID
-     * @param runId - Run ID
-     */
-    async list(workspaceId: string, runId: string): Promise<APIResponse<CheckpointsResponse>> {
-        return this.client.GET<CheckpointsResponse>("/v1/api/workspaces/{workspaceId}/runs/{runId}/checkpoints", {
-            params: { path: { workspaceId, runId } },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Get a specific checkpoint.
-     * @param workspaceId - Workspace ID
-     * @param runId - Run ID
-     * @param checkpointId - Checkpoint ID
-     */
-    async get(workspaceId: string, runId: string, checkpointId: string): Promise<APIResponse<Checkpoint>> {
-        return this.client.GET<Checkpoint>("/v1/api/workspaces/{workspaceId}/runs/{runId}/checkpoints/{checkpointId}", {
-            params: { path: { workspaceId, runId, checkpointId } },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Replay from a checkpoint.
-     * @param workspaceId - Workspace ID
-     * @param runId - Run ID
-     * @param checkpointId - Checkpoint ID
-     * @param options - Replay options
-     */
-    async replay(workspaceId: string, runId: string, checkpointId: string, options?: {
-        create_new_thread?: boolean;
-        modified_input?: string;
-    }): Promise<APIResponse<ReplayResponse>> {
-        return this.client.POST<ReplayResponse>("/v1/api/workspaces/{workspaceId}/runs/{runId}/checkpoints/{checkpointId}/replay", {
-            params: { path: { workspaceId, runId, checkpointId } },
-            body: options ?? {},
-            headers: this.headers(),
-        });
-    }
-}

package/src/modules/contracts.ts

@@ -1,80 +0,0 @@
-import type { APIResponse, RawClient } from "../client/raw.js";
-
-export interface ContractsValidationIssue {
-    code: string;
-    message: string;
-    path?: string;
-    severity?: string;
-}
-
-export type ContractsErrorCode =
-    | "CONTRACT_ID_INVALID"
-    | "RUNTIME_PACKAGE_COMPILE_INVALID"
-    | "INTERNAL_UNAUTHORIZED"
-    | "KERNEL_UNAVAILABLE"
-    | "KERNEL_ERROR"
-    | "INTERNAL_ERROR"
-    | "VALIDATION_ERROR";
-
-export interface ContractsErrorResponse {
-    code: ContractsErrorCode;
-    message: string;
-    errors?: ContractsValidationIssue[];
-    supported_contract_ids?: string[];
-}
-
-export interface ContractsSupportedResponse {
-    contract_ids: string[];
-}
-
-export interface ContractsValidateRequest {
-    contract_id: string;
-    spec: unknown;
-}
-
-export interface ContractsValidateResponse {
-    contract_id: string;
-    valid: boolean;
-    errors: ContractsValidationIssue[];
-    warnings: ContractsValidationIssue[];
-}
-
-export interface ContractsCompileRuntimePackageRequest {
-    ir_spec: unknown;
-    capability_registry_spec: unknown;
-    policy_refs?: Record<string, unknown>;
-    runtime_config_refs?: Record<string, unknown>;
-    package_id?: string;
-    metadata?: Record<string, unknown>;
-    compiled_at?: string;
-}
-
-export interface ContractsCompileRuntimePackageResponse {
-    package_spec: Record<string, unknown>;
-}
-
-export class ContractsModule {
-    constructor(private client: RawClient, private headers: () => Record<string, string>) {}
-
-    async supported(): Promise<APIResponse<ContractsSupportedResponse>> {
-        return this.client.GET<ContractsSupportedResponse>("/v1/api/contracts/supported", {
-            headers: this.headers(),
-        });
-    }
-
-    async validate(body: ContractsValidateRequest): Promise<APIResponse<ContractsValidateResponse>> {
-        return this.client.POST<ContractsValidateResponse>("/v1/api/contracts/validate", {
-            body,
-            headers: this.headers(),
-        });
-    }
-
-    async compileRuntimePackage(
-        body: ContractsCompileRuntimePackageRequest,
-    ): Promise<APIResponse<ContractsCompileRuntimePackageResponse>> {
-        return this.client.POST<ContractsCompileRuntimePackageResponse>("/v1/api/contracts/compile/runtime-package", {
-            body,
-            headers: this.headers(),
-        });
-    }
-}

package/src/modules/credentials.ts

@@ -1,216 +0,0 @@
-/**
- * Credentials Module - Fully Typed
- */
-
-import type { APIResponse, components, RawClient } from "../client/raw.js";
-
-type CreateCredentialRequest = components["schemas"]["CreateCredentialRequest"];
-type UpdateCredentialRequest = components["schemas"]["UpdateCredentialRequest"];
-
-export interface Credential {
-    id: string;
-    credential_instance_ref?: string;
-    name: string;
-    scope: "workspace" | "tenant";
-    type_id?: string;
-    type?: string;
-    credential_type_ref?: string;
-    workspace_id?: string;
-    tenant_id: string;
-    sharing_mode: "private" | "shared";
-    status: "active" | "disabled" | "expired";
-    created_at: string;
-    updated_at: string;
-}
-
-export interface CredentialListResponse {
-    items: Credential[];
-    total: number;
-}
-
-export interface CredentialType {
-    id: string;
-    name: string;
-    credential_type_ref?: string;
-    display_name?: string;
-    description?: string;
-    provider_family?: string;
-    version?: string;
-    status?: string;
-    masking_policy?: string;
-    materialization_policy?: string;
-    schema_public_json?: Record<string, unknown> | null;
-    schema_secret_json?: Record<string, unknown> | null;
-}
-
-export interface CredentialTypesResponse {
-    items: CredentialType[];
-    count?: number;
-}
-
-export interface ValidateCredentialResponse {
-    valid: boolean;
-    error?: string;
-}
-
-export class CredentialsModule {
-    constructor(
-        private client: RawClient,
-        private getWorkspaceId: () => string,
-        private headers: () => Record<string, string>
-    ) { }
-
-    /**
-     * List all credentials.
-     */
-    async list(params?: {
-        workspace_id?: string;
-        scope?: string;
-        type?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<APIResponse<CredentialListResponse>> {
-        return this.client.GET<CredentialListResponse>("/v1/api/credentials", {
-            params: { query: params },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Get a credential by ID.
-     */
-    async get(credentialId: string, includeValues: boolean = false): Promise<APIResponse<Credential>> {
-        return this.client.GET<Credential>("/v1/api/credentials/{id}", {
-            params: {
-                path: { id: credentialId },
-                query: { includeValues }
-            },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Create a new credential.
-     */
-    async create(body: {
-        name: string;
-        scope?: "workspace" | "tenant";
-        type_id?: string;
-        type?: string;
-        workspace_id?: string;
-        values?: Record<string, unknown>;
-        data?: Record<string, unknown>;
-        sharing_mode?: "private" | "shared";
-    }): Promise<APIResponse<Credential>> {
-        return this.client.POST<Credential>("/v1/api/credentials", {
-            body: {
-                ...body,
-                workspace_id: body.workspace_id || (this.getWorkspaceId() ? this.getWorkspaceId() : undefined),
-            },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Update a credential.
-     * Uses PATCH per backend CredentialsController.
-     */
-    async update(credentialId: string, body: {
-        name?: string;
-        values?: Record<string, unknown>;
-        status?: string;
-        sharing_mode?: string;
-    }): Promise<APIResponse<Credential>> {
-        return this.client.PATCH<Credential>("/v1/api/credentials/{id}", {
-            params: { path: { id: credentialId } },
-            body,
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Delete a credential.
-     */
-    async delete(credentialId: string): Promise<APIResponse<void>> {
-        return this.client.DELETE<void>("/v1/api/credentials/{id}", {
-            params: { path: { id: credentialId } },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * List available credential types.
-     */
-    async listTypes(): Promise<APIResponse<CredentialTypesResponse>> {
-        const response = await this.client.GET<unknown>("/v1/api/credential-types", {
-            headers: this.headers(),
-        });
-
-        if (!response.data || response.error) {
-            return response as APIResponse<CredentialTypesResponse>;
-        }
-
-        const raw = response.data as Record<string, unknown>;
-        const rawItems = Array.isArray(raw)
-            ? raw
-            : Array.isArray(raw.items)
-                ? raw.items
-                : [];
-
-        const items: CredentialType[] = rawItems
-            .filter((item): item is Record<string, unknown> => Boolean(item) && typeof item === "object")
-            .map((item) => ({
-                id: String(item.id ?? ""),
-                name: String(item.name ?? item.key ?? ""),
-                credential_type_ref: typeof item.credential_type_ref === "string"
-                    ? item.credential_type_ref
-                    : undefined,
-                display_name: typeof item.display_name === "string"
-                    ? item.display_name
-                    : typeof item.displayName === "string"
-                        ? item.displayName
-                        : undefined,
-                description: typeof item.description === "string" ? item.description : undefined,
-                provider_family: typeof item.provider_family === "string" ? item.provider_family : undefined,
-                version: typeof item.version === "string" ? item.version : undefined,
-                status: typeof item.status === "string" ? item.status : undefined,
-                masking_policy: typeof item.masking_policy === "string" ? item.masking_policy : undefined,
-                materialization_policy: typeof item.materialization_policy === "string" ? item.materialization_policy : undefined,
-                schema_public_json: item.schema_public_json && typeof item.schema_public_json === "object"
-                    ? item.schema_public_json as Record<string, unknown>
-                    : null,
-                schema_secret_json: item.schema_secret_json && typeof item.schema_secret_json === "object"
-                    ? item.schema_secret_json as Record<string, unknown>
-                    : null,
-            }))
-            .filter((item) => item.id && item.name);
-
-        return {
-            ...response,
-            data: {
-                items,
-                count: typeof raw.count === "number" ? raw.count : items.length,
-            },
-        };
-    }
-
-    /**
-     * Validate a credential.
-     */
-    async validate(credentialId: string): Promise<APIResponse<ValidateCredentialResponse>> {
-        return this.client.POST<ValidateCredentialResponse>("/v1/api/credentials/{id}/validate", {
-            params: { path: { id: credentialId } },
-            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(),
-        });
-    }
-}