@paid-ai/paid-node 0.0.8 → 0.2.0

package/dist/cjs/tracing/wrappers/vercelAIWrapper.js

@@ -0,0 +1,327 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateText = generateText;
+exports.streamText = streamText;
+exports.generateObject = generateObject;
+exports.streamObject = streamObject;
+exports.embed = embed;
+exports.embedMany = embedMany;
+const api_1 = require("@opentelemetry/api");
+const tracing_js_1 = require("../tracing.js");
+const ai_1 = require("ai");
+function getModelInfo(model) {
+    if (model === null || model === void 0 ? void 0 : model.modelId) {
+        const modelId = model.modelId;
+        if (modelId.startsWith('gpt-') || modelId.startsWith('text-embedding-') || modelId.startsWith('dall-e-')) {
+            return { system: 'openai', modelName: modelId };
+        }
+        if (modelId.startsWith('claude-')) {
+            return { system: 'anthropic', modelName: modelId };
+        }
+        if (modelId.startsWith('mistral-') || modelId.startsWith('codestral-')) {
+            return { system: 'mistral', modelName: modelId };
+        }
+        if (modelId.includes('gemini')) {
+            return { system: 'google', modelName: modelId };
+        }
+    }
+    if (model === null || model === void 0 ? void 0 : model.provider) {
+        return { system: model.provider, modelName: model.modelId };
+    }
+    return { system: 'unknown' };
+}
+function extractUsageMetrics(usage) {
+    const usageAttrs = {};
+    const inputTokens = usage.promptTokens || usage.prompt_tokens || usage.inputTokens;
+    const outputTokens = usage.completionTokens || usage.completion_tokens || usage.outputTokens;
+    const cachedTokens = usage.cachedPromptTokens || usage.cached_prompt_tokens || usage.cachedInputTokens;
+    if (inputTokens !== undefined) {
+        usageAttrs["gen_ai.usage.input_tokens"] = inputTokens;
+    }
+    if (outputTokens !== undefined) {
+        usageAttrs["gen_ai.usage.output_tokens"] = outputTokens;
+    }
+    if (cachedTokens !== undefined) {
+        usageAttrs["gen_ai.usage.cached_input_tokens"] = cachedTokens;
+    }
+    if (usage.tokens !== undefined && inputTokens === undefined) {
+        usageAttrs["gen_ai.usage.input_tokens"] = usage.tokens;
+    }
+    return usageAttrs;
+}
+function validateContext() {
+    const externalCustomerId = (0, tracing_js_1.getCustomerIdStorage)();
+    const token = (0, tracing_js_1.getTokenStorage)();
+    if (!token || !externalCustomerId) {
+        throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
+    }
+    return {
+        externalCustomerId,
+        externalAgentId: (0, tracing_js_1.getAgentIdStorage)(),
+        token,
+    };
+}
+function generateText(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.generateText", (span) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield (0, ai_1.generateText)(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                if ((_a = result.response) === null || _a === void 0 ? void 0 : _a.modelId) {
+                    span.setAttribute("gen_ai.response.model", result.response.modelId);
+                }
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+function streamText(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.streamText", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const originalOnFinish = params.onFinish;
+                const wrappedParams = Object.assign(Object.assign({}, params), { onFinish: (result) => {
+                        if (result.usage) {
+                            const usageAttrs = extractUsageMetrics(result.usage);
+                            span.setAttributes(usageAttrs);
+                        }
+                        if (originalOnFinish) {
+                            originalOnFinish(result);
+                        }
+                        span.setStatus({ code: api_1.SpanStatusCode.OK });
+                        span.end();
+                    } });
+                const result = (0, ai_1.streamText)(wrappedParams);
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+function generateObject(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.generateObject", (span) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield (0, ai_1.generateObject)(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                if ((_a = result.response) === null || _a === void 0 ? void 0 : _a.modelId) {
+                    span.setAttribute("gen_ai.response.model", result.response.modelId);
+                }
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+function streamObject(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.streamObject", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const originalOnFinish = params.onFinish;
+                const wrappedParams = Object.assign(Object.assign({}, params), { onFinish: (result) => {
+                        if (result.usage) {
+                            const usageAttrs = extractUsageMetrics(result.usage);
+                            span.setAttributes(usageAttrs);
+                        }
+                        if (originalOnFinish) {
+                            originalOnFinish(result);
+                        }
+                        span.setStatus({ code: api_1.SpanStatusCode.OK });
+                        span.end();
+                    } });
+                const result = (0, ai_1.streamObject)(wrappedParams);
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+        }));
+    });
+}
+function embed(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.embed", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "embeddings",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield (0, ai_1.embed)(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+function embedMany(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.embedMany", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "embeddings",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield (0, ai_1.embedMany)(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+exports.default = {
+    generateText,
+    streamText,
+    generateObject,
+    streamObject,
+    embed,
+    embedMany,
+};

package/dist/cjs/vercel-wrapper/index.d.ts

@@ -0,0 +1 @@
+export { generateText as paidVercelGenerateText, streamText as paidVercelStreamText, generateObject as paidVercelGenerateObject, streamObject as paidVercelStreamObject, embed as paidVercelEmbed, embedMany as paidVercelEmbedMany, } from "../tracing/wrappers/vercelAIWrapper.js";

package/dist/cjs/vercel-wrapper/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paidVercelEmbedMany = exports.paidVercelEmbed = exports.paidVercelStreamObject = exports.paidVercelGenerateObject = exports.paidVercelStreamText = exports.paidVercelGenerateText = void 0;
+var vercelAIWrapper_js_1 = require("../tracing/wrappers/vercelAIWrapper.js");
+Object.defineProperty(exports, "paidVercelGenerateText", { enumerable: true, get: function () { return vercelAIWrapper_js_1.generateText; } });
+Object.defineProperty(exports, "paidVercelStreamText", { enumerable: true, get: function () { return vercelAIWrapper_js_1.streamText; } });
+Object.defineProperty(exports, "paidVercelGenerateObject", { enumerable: true, get: function () { return vercelAIWrapper_js_1.generateObject; } });
+Object.defineProperty(exports, "paidVercelStreamObject", { enumerable: true, get: function () { return vercelAIWrapper_js_1.streamObject; } });
+Object.defineProperty(exports, "paidVercelEmbed", { enumerable: true, get: function () { return vercelAIWrapper_js_1.embed; } });
+Object.defineProperty(exports, "paidVercelEmbedMany", { enumerable: true, get: function () { return vercelAIWrapper_js_1.embedMany; } });

package/dist/cjs/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.0.8";
+export declare const SDK_VERSION = "0.2.0";

package/dist/cjs/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "0.0.8";
+exports.SDK_VERSION = "0.2.0";

package/dist/cjs/wrapper/BatchUsage.d.ts

@@ -1,8 +1,8 @@
 import * as core from "../core/index.js";
-import { Usage as UsageClient } from "../api/resources/usage/client/Client";
+import { Usage as UsageClient } from "../api/resources/usage/client/Client.js";
 import * as Paid from "../api/types/Signal.js";
 export declare class Usage extends UsageClient {
     private signals;
-    flush(requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<unknown[]>;
-    recordUsage(signal?: Paid.Signal, requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<unknown[]>;
+    flush(requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<void>;
+    record(signal?: Paid.Signal, requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<void>;
 }

package/dist/cjs/wrapper/BatchUsage.js

@@ -35,8 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Usage = void 0;
 const core = __importStar(require("../core/index.js"));
-const Client_1 = require("../api/resources/usage/client/Client");
-class Usage extends Client_1.Usage {
+const Client_js_1 = require("../api/resources/usage/client/Client.js");
+class Usage extends Client_js_1.Usage {
     constructor() {
         super(...arguments);
         this.signals = [];
@@ -44,7 +44,7 @@ class Usage extends Client_1.Usage {
     flush(requestOptions) {
         return this.recordBulk({ signals: this.signals }, requestOptions);
     }
-    recordUsage(signal = {}, requestOptions) {
+    record(signal = {}, requestOptions) {
         if (!this.signals) {
             this.signals = [];
         }
@@ -54,7 +54,7 @@ class Usage extends Client_1.Usage {
             this.signals = [];
             return response;
         }
-        return core.HttpResponsePromise.fromResult({ data: [], rawResponse: {} });
+        return core.HttpResponsePromise.fromResult({ data: undefined, rawResponse: {} });
     }
 }
 exports.Usage = Usage;

package/dist/esm/Client.d.mts

@@ -41,4 +41,26 @@ export declare class PaidClient {
     get contacts(): Contacts;
     get orders(): Orders;
     get usage(): Usage;
+    initializeTracing(collectorEndpoint?: string): Promise<void>;
+    trace<T extends (...args: any[]) => any>(externalCustomerId: string, fn: T, externalAgentId?: string, ...args: Parameters<T>): Promise<ReturnType<T>>;
+    /**
+     * Sends Paid signal. Needs to be called as part of callback to Paid.trace().
+     * When enableCostTracing flag is on, signal is associated
+     * with cost traces from the same Paid.trace() context.
+     *
+     * @param eventName - The name of the signal.
+     * @param enableCostTracing - Whether to associate this signal with cost traces
+     * from the current Paid.trace() context (default: false)
+     * @param data - Optional additional data to include with the signal
+     *
+     * @remarks
+     * When enableCostTracing is on, the signal will be associated with cost
+     * traces within the same Paid.trace() context.
+     * It is advised to only make one call to this function
+     * with enableCostTracing per Paid.trace() context.
+     * Otherwise, there will be multiple signals that refer to the same costs.
+     */
+    signal(eventName: string): void;
+    signal(eventName: string, data: Record<string, any>): void;
+    signal(eventName: string, enableCostTracing: boolean, data?: Record<string, any>): void;
 }

package/dist/esm/Client.mjs

@@ -1,6 +1,15 @@
 /**
  * This file was auto-generated by Fern from our API Definition.
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import * as core from "./core/index.mjs";
 import { mergeHeaders } from "./core/headers.mjs";
 import { Customers } from "./api/resources/customers/client/Client.mjs";
@@ -8,13 +17,15 @@ import { Agents } from "./api/resources/agents/client/Client.mjs";
 import { Contacts } from "./api/resources/contacts/client/Client.mjs";
 import { Orders } from "./api/resources/orders/client/Client.mjs";
 import { Usage } from "./wrapper/BatchUsage.mjs";
+import { _trace, _initializeTracing } from "./tracing/tracing.mjs";
+import { _signal } from "./tracing/signal.mjs";
 export class PaidClient {
     constructor(_options) {
         this._options = Object.assign(Object.assign({}, _options), { headers: mergeHeaders({
                 "X-Fern-Language": "JavaScript",
                 "X-Fern-SDK-Name": "@paid-ai/paid-node",
-                "X-Fern-SDK-Version": "0.0.6",
-                "User-Agent": "@paid-ai/paid-node/0.0.6",
+                "X-Fern-SDK-Version": "0.2.0",
+                "User-Agent": "@paid-ai/paid-node/0.2.0",
                 "X-Fern-Runtime": core.RUNTIME.type,
                 "X-Fern-Runtime-Version": core.RUNTIME.version,
             }, _options === null || _options === void 0 ? void 0 : _options.headers) });
@@ -39,4 +50,36 @@ export class PaidClient {
         var _a;
         return ((_a = this._usage) !== null && _a !== void 0 ? _a : (this._usage = new Usage(this._options)));
     }
+    // Need to call this method before using tracing or creating wrappers.
+    initializeTracing(collectorEndpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenSupplier = this._options.token;
+            const token = typeof tokenSupplier === "function" ? yield tokenSupplier() : tokenSupplier;
+            const resolvedToken = yield Promise.resolve(token);
+            _initializeTracing(resolvedToken, collectorEndpoint);
+        });
+    }
+    // Use this method to track actions like LLM costs and sending signals.
+    // The callback to this function is the work that you want to trace.
+    trace(externalCustomerId, fn, externalAgentId, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _trace(externalCustomerId, fn, externalAgentId, ...args);
+        });
+    }
+    signal(eventName, enableCostTracingOrData, data) {
+        let enableCostTracing = false;
+        let finalData;
+        if (typeof enableCostTracingOrData === 'boolean') {
+            // Case: signal(eventName, boolean, data?)
+            enableCostTracing = enableCostTracingOrData;
+            finalData = data;
+        }
+        else if (typeof enableCostTracingOrData === 'object') {
+            // Case: signal(eventName, data)
+            enableCostTracing = false;
+            finalData = enableCostTracingOrData;
+        }
+        // Case: signal(eventName) - both remain default/undefined
+        return _signal(eventName, enableCostTracing, finalData);
+    }
 }

package/dist/esm/anthropic-wrapper/index.d.mts

@@ -0,0 +1 @@
+export { PaidAnthropic } from "../tracing/wrappers/anthropicWrapper.mjs";

package/dist/esm/anthropic-wrapper/index.mjs

@@ -0,0 +1 @@
+export { PaidAnthropic } from "../tracing/wrappers/anthropicWrapper.mjs";

package/dist/esm/api/resources/agents/client/Client.d.mts

@@ -41,8 +41,9 @@ export declare class Agents {
      *
      * @example
      *     await client.agents.create({
-     *         name: "name",
-     *         description: "description"
+     *         name: "Acme Agent",
+     *         description: "Acme Agent is an AI agent that does things.",
+     *         externalId: "acme-agent"
      *     })
      */
     create(request: Paid.AgentCreate, requestOptions?: Agents.RequestOptions): core.HttpResponsePromise<Paid.Agent>;
@@ -62,7 +63,36 @@ export declare class Agents {
      * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @example
-     *     await client.agents.update("agentId", {})
+     *     await client.agents.update("agentId", {
+     *         name: "Acme Agent (Updated)",
+     *         agentAttributes: [{
+     *                 name: "Emails sent signal",
+     *                 active: true,
+     *                 pricing: {
+     *                     eventName: "emails_sent",
+     *                     taxable: true,
+     *                     chargeType: "usage",
+     *                     pricingModel: "PerUnit",
+     *                     billingFrequency: "monthly",
+     *                     pricePoints: {
+     *                         "USD": {
+     *                             tiers: [{
+     *                                     minQuantity: 0,
+     *                                     maxQuantity: 10,
+     *                                     unitPrice: 100
+     *                                 }, {
+     *                                     minQuantity: 11,
+     *                                     maxQuantity: 100,
+     *                                     unitPrice: 90
+     *                                 }, {
+     *                                     minQuantity: 101,
+     *                                     unitPrice: 80
+     *                                 }]
+     *                         }
+     *                     }
+     *                 }
+     *             }]
+     *     })
      */
     update(agentId: string, request: Paid.AgentUpdate, requestOptions?: Agents.RequestOptions): core.HttpResponsePromise<Paid.Agent>;
     private __update;
@@ -90,7 +120,25 @@ export declare class Agents {
      * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @example
-     *     await client.agents.updateByExternalId("externalId", {})
+     *     await client.agents.updateByExternalId("externalId", {
+     *         name: "Acme Agent (Updated)",
+     *         agentAttributes: [{
+     *                 name: "Emails sent signal",
+     *                 active: true,
+     *                 pricing: {
+     *                     eventName: "emails_sent",
+     *                     taxable: true,
+     *                     chargeType: "usage",
+     *                     pricingModel: "PerUnit",
+     *                     billingFrequency: "monthly",
+     *                     pricePoints: {
+     *                         "USD": {
+     *                             unitPrice: 150
+     *                         }
+     *                     }
+     *                 }
+     *             }]
+     *     })
      */
     updateByExternalId(externalId: string, request: Paid.AgentUpdate, requestOptions?: Agents.RequestOptions): core.HttpResponsePromise<Paid.Agent>;
     private __updateByExternalId;

package/dist/esm/api/resources/agents/client/Client.mjs

@@ -72,8 +72,9 @@ export class Agents {
      *
      * @example
      *     await client.agents.create({
-     *         name: "name",
-     *         description: "description"
+     *         name: "Acme Agent",
+     *         description: "Acme Agent is an AI agent that does things.",
+     *         externalId: "acme-agent"
      *     })
      */
     create(request, requestOptions) {
@@ -174,7 +175,36 @@ export class Agents {
      * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @example
-     *     await client.agents.update("agentId", {})
+     *     await client.agents.update("agentId", {
+     *         name: "Acme Agent (Updated)",
+     *         agentAttributes: [{
+     *                 name: "Emails sent signal",
+     *                 active: true,
+     *                 pricing: {
+     *                     eventName: "emails_sent",
+     *                     taxable: true,
+     *                     chargeType: "usage",
+     *                     pricingModel: "PerUnit",
+     *                     billingFrequency: "monthly",
+     *                     pricePoints: {
+     *                         "USD": {
+     *                             tiers: [{
+     *                                     minQuantity: 0,
+     *                                     maxQuantity: 10,
+     *                                     unitPrice: 100
+     *                                 }, {
+     *                                     minQuantity: 11,
+     *                                     maxQuantity: 100,
+     *                                     unitPrice: 90
+     *                                 }, {
+     *                                     minQuantity: 101,
+     *                                     unitPrice: 80
+     *                                 }]
+     *                         }
+     *                     }
+     *                 }
+     *             }]
+     *     })
      */
     update(agentId, request, requestOptions) {
         return core.HttpResponsePromise.fromPromise(this.__update(agentId, request, requestOptions));
@@ -322,7 +352,25 @@ export class Agents {
      * @param {Agents.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @example
-     *     await client.agents.updateByExternalId("externalId", {})
+     *     await client.agents.updateByExternalId("externalId", {
+     *         name: "Acme Agent (Updated)",
+     *         agentAttributes: [{
+     *                 name: "Emails sent signal",
+     *                 active: true,
+     *                 pricing: {
+     *                     eventName: "emails_sent",
+     *                     taxable: true,
+     *                     chargeType: "usage",
+     *                     pricingModel: "PerUnit",
+     *                     billingFrequency: "monthly",
+     *                     pricePoints: {
+     *                         "USD": {
+     *                             unitPrice: 150
+     *                         }
+     *                     }
+     *                 }
+     *             }]
+     *     })
      */
     updateByExternalId(externalId, request, requestOptions) {
         return core.HttpResponsePromise.fromPromise(this.__updateByExternalId(externalId, request, requestOptions));

package/dist/esm/api/resources/agents/client/requests/AgentCreate.d.mts

@@ -4,8 +4,9 @@
 /**
  * @example
  *     {
- *         name: "name",
- *         description: "description"
+ *         name: "Acme Agent",
+ *         description: "Acme Agent is an AI agent that does things.",
+ *         externalId: "acme-agent"
  *     }
  */
 export interface AgentCreate {
@@ -13,4 +14,5 @@ export interface AgentCreate {
     description: string;
     agentCode?: string;
     externalId?: string;
+    active?: boolean;
 }