telnyx 7.7.0 → 7.9.0

package/src/resources/ai/anthropic/v1.ts

@@ -0,0 +1,157 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+
+export class V1 extends APIResource {
+  /**
+   * Send a message to a language model using the Anthropic Messages API format. This
+   * endpoint is compatible with the
+   * [Anthropic Messages API](https://docs.anthropic.com/en/api/messages) and may be
+   * used with the Anthropic JS or Python SDK by setting the base URL to
+   * `https://api.telnyx.com/v2/ai/anthropic`.
+   *
+   * The endpoint translates Anthropic-format requests into Telnyx's inference
+   * internals, then translates the response back to the Anthropic message shape.
+   * Streaming responses use Anthropic SSE event types (`message_start`,
+   * `content_block_start`, `content_block_delta`, `content_block_stop`,
+   * `message_delta`, `message_stop`).
+   *
+   * @example
+   * ```ts
+   * const response = await client.ai.anthropic.v1.messages({
+   *   max_tokens: 1024,
+   *   messages: [{ role: 'user', content: 'Hello, world!' }],
+   *   model: 'zai-org/GLM-5.2',
+   *   system: 'You are a friendly chatbot.',
+   * });
+   * ```
+   */
+  messages(body: V1MessagesParams, options?: RequestOptions): APIPromise<V1MessagesResponse> {
+    return this._client.post('/ai/anthropic/v1/messages', { body, ...options });
+  }
+}
+
+/**
+ * An Anthropic-format message response with `type: "message"`, `role`, `content`,
+ * `stop_reason`, `stop_sequence`, and `usage`. When `stream` is true, the response
+ * is a text/event-stream of Anthropic SSE events.
+ */
+export type V1MessagesResponse = { [key: string]: unknown };
+
+export interface V1MessagesParams {
+  /**
+   * The maximum number of tokens to generate in the response.
+   */
+  max_tokens: number;
+
+  /**
+   * The messages to send to the model, following the
+   * [Anthropic Messages API](https://docs.anthropic.com/en/api/messages) format.
+   */
+  messages: Array<{ [key: string]: unknown }>;
+
+  /**
+   * The model to use for generating the response, for example `zai-org/GLM-5.2` or
+   * another model available from the Telnyx models endpoint.
+   */
+  model: string;
+
+  /**
+   * If you are using an external inference provider, this field allows you to pass
+   * along a reference to your API key. After creating an
+   * [integration secret](https://developers.telnyx.com/api-reference/integration-secrets/create-a-secret)
+   * for your API key, pass the secret's `identifier` in this field.
+   */
+  api_key_ref?: string;
+
+  /**
+   * The billing group ID to associate with this request.
+   */
+  billing_group_id?: string;
+
+  /**
+   * Configuration for model fallback behavior when the primary model is unavailable.
+   */
+  fallback_config?: { [key: string]: unknown };
+
+  /**
+   * Maximum number of retries for the request.
+   */
+  max_retries?: number;
+
+  /**
+   * List of MCP (Model Context Protocol) servers to make available to the model.
+   */
+  mcp_servers?: Array<{ [key: string]: unknown }>;
+
+  /**
+   * An object describing metadata about the request.
+   */
+  metadata?: { [key: string]: unknown };
+
+  /**
+   * Service tier for the request.
+   */
+  service_tier?: string;
+
+  /**
+   * Custom sequences that will cause the model to stop generating.
+   */
+  stop_sequences?: Array<string>;
+
+  /**
+   * Whether to stream the response as Anthropic-format Server-Sent Events.
+   */
+  stream?: boolean;
+
+  /**
+   * System prompt. Can be a string or an array of content blocks following the
+   * Anthropic API format.
+   */
+  system?: string | Array<{ [key: string]: unknown }>;
+
+  /**
+   * Amount of randomness injected into the response. Ranges from 0 to 1.
+   */
+  temperature?: number;
+
+  /**
+   * Extended thinking configuration for models that support it. Set `type` to
+   * `enabled` to turn on extended thinking.
+   */
+  thinking?: { [key: string]: unknown };
+
+  /**
+   * Request timeout in seconds.
+   */
+  timeout?: number;
+
+  /**
+   * Controls how the model uses tools, following the Anthropic API format.
+   */
+  tool_choice?: { [key: string]: unknown };
+
+  /**
+   * Definitions of tools that the model may use, following the Anthropic API format.
+   */
+  tools?: Array<{ [key: string]: unknown }>;
+
+  /**
+   * Top-k sampling parameter. Only sample from the top K options for each subsequent
+   * token.
+   */
+  top_k?: number;
+
+  /**
+   * Nucleus sampling parameter. Use temperature or top_p, but not both.
+   */
+  top_p?: number;
+
+  [k: string]: unknown;
+}
+
+export declare namespace V1 {
+  export { type V1MessagesResponse as V1MessagesResponse, type V1MessagesParams as V1MessagesParams };
+}

package/src/resources/ai/anthropic.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './anthropic/index';

package/src/resources/ai/assistants/assistants.ts

@@ -4,6 +4,7 @@ import { APIResource } from '../../../core/resource';
 import * as AssistantsAPI from './assistants';
 import * as Shared from '../../shared';
 import * as ChatAPI from '../chat';
+import * as ToolsAPI from '../tools';
 import * as CanaryDeploysAPI from './canary-deploys';
 import {
   CanaryDeploy,
@@ -37,7 +38,7 @@ import {
 } from './scheduled-events';
 import * as TagsAPI from './tags';
 import { TagAddParams, TagRemoveParams, Tags, TagsResponse } from './tags';
-import * as ToolsAPI from './tools';
+import * as AssistantsToolsAPI from './tools';
 import {
   ToolAddParams,
   ToolAddResponse,
@@ -77,7 +78,7 @@ export class Assistants extends APIResource {
   tests: TestsAPI.Tests = new TestsAPI.Tests(this._client);
   canaryDeploys: CanaryDeploysAPI.CanaryDeploys = new CanaryDeploysAPI.CanaryDeploys(this._client);
   scheduledEvents: ScheduledEventsAPI.ScheduledEvents = new ScheduledEventsAPI.ScheduledEvents(this._client);
-  tools: ToolsAPI.Tools = new ToolsAPI.Tools(this._client);
+  tools: AssistantsToolsAPI.Tools = new AssistantsToolsAPI.Tools(this._client);
   versions: VersionsAPI.Versions = new VersionsAPI.Versions(this._client);
   tags: TagsAPI.Tags = new TagsAPI.Tags(this._client);
   instructions: InstructionsAPI.Instructions = new InstructionsAPI.Instructions(this._client);
@@ -375,6 +376,7 @@ export interface AssistantMcpServer {
  */
 export type AssistantTool =
   | InferenceEmbeddingWebhookToolParams
+  | AssistantTool.ClientSideTool
   | RetrievalTool
   | AssistantTool.Handoff
   | HangupTool
@@ -383,9 +385,58 @@ export type AssistantTool =
   | AssistantTool.Refer
   | AssistantTool.SendDtmf
   | AssistantTool.SendMessage
-  | AssistantTool.SkipTurn;
+  | AssistantTool.SkipTurn
+  | AssistantTool.Pay;
 
 export namespace AssistantTool {
+  export interface ClientSideTool {
+    client_side_tool: ClientSideTool.ClientSideTool;
+
+    type: 'client_side_tool';
+  }
+
+  export namespace ClientSideTool {
+    export interface ClientSideTool {
+      /**
+       * The description of the tool.
+       */
+      description: string;
+
+      /**
+       * The name of the tool.
+       */
+      name: string;
+
+      /**
+       * The parameters the tool accepts, described as a JSON Schema object. See the
+       * [JSON Schema reference](https://json-schema.org/understanding-json-schema) for
+       * documentation about the format
+       */
+      parameters: ClientSideTool.Parameters;
+    }
+
+    export namespace ClientSideTool {
+      /**
+       * The parameters the tool accepts, described as a JSON Schema object. See the
+       * [JSON Schema reference](https://json-schema.org/understanding-json-schema) for
+       * documentation about the format
+       */
+      export interface Parameters {
+        /**
+         * The properties of the parameters.
+         */
+        properties?: { [key: string]: unknown };
+
+        /**
+         * The required properties of the parameters.
+         */
+        required?: Array<string>;
+
+        type?: 'object';
+      }
+    }
+  }
+
   /**
    * The handoff tool allows the assistant to hand off control of the conversation to
    * another AI assistant. By default, this will happen transparently to the end
@@ -850,6 +901,18 @@ export namespace AssistantTool {
       description?: string;
     }
   }
+
+  /**
+   * (BETA) The pay tool allows the assistant to collect card payments from the
+   * caller via DTMF during the conversation. Recording is automatically paused while
+   * the pay tool is active and resumes when the payment flow completes. The
+   * connector_name must reference a pay connector configured in the Telnyx API.
+   */
+  export interface Pay {
+    pay: ToolsAPI.PayToolParams;
+
+    type: 'pay';
+  }
 }
 
 export interface AssistantsList {
@@ -2465,7 +2528,7 @@ export interface TranscriptionSettings {
    * - `xai/grok-stt` is a multilingual Grok STT model.
    * - `soniox/stt-rt-v4` is a multilingual streaming model with automatic language
    *   detection and configurable endpointing.
-   * - `parakeet/tdt-0.6b-v3` is a multilingual transcription model with automatic
+   * - `nvidia/parakeet-v3` is a multilingual transcription model with automatic
    *   language detection.
    */
   model?:
@@ -2476,7 +2539,7 @@ export interface TranscriptionSettings {
     | 'assemblyai/universal-streaming'
     | 'xai/grok-stt'
     | 'soniox/stt-rt-v4'
-    | 'parakeet/tdt-0.6b-v3'
+    | 'nvidia/parakeet-v3'
     | 'distil-whisper/distil-large-v2'
     | 'openai/whisper-large-v3-turbo';
 

package/src/resources/ai/chat.ts

@@ -2,28 +2,8 @@
 
 import { APIResource } from '../../core/resource';
 import * as ChatAPI from './chat';
-import { APIPromise } from '../../core/api-promise';
-import { RequestOptions } from '../../internal/request-options';
 
-/**
- * Generate text with LLMs
- */
-export class Chat extends APIResource {
-  /**
-   * **Deprecated**: Use `POST /v2/ai/openai/chat/completions` instead. Chat with a
-   * language model. This endpoint is consistent with the
-   * [OpenAI Chat Completions API](https://platform.openai.com/docs/api-reference/chat)
-   * and may be used with the OpenAI JS or Python SDK.
-   *
-   * @deprecated
-   */
-  createCompletion(
-    body: ChatCreateCompletionParams,
-    options?: RequestOptions,
-  ): APIPromise<ChatCreateCompletionResponse> {
-    return this._client.post('/ai/chat/completions', { body, ...options });
-  }
-}
+export class Chat extends APIResource {}
 
 export interface BucketIDs {
   /**
@@ -244,218 +224,6 @@ export namespace ChatCompletionRequest {
   }
 }
 
-export type ChatCreateCompletionResponse = { [key: string]: unknown };
-
-export interface ChatCreateCompletionParams {
-  /**
-   * A list of the previous chat messages for context.
-   */
-  messages: Array<ChatCreateCompletionParams.Message>;
-
-  /**
-   * If you are using an external inference provider like xAI or OpenAI, this field
-   * allows you to pass along a reference to your API key. After creating an
-   * [integration secret](https://developers.telnyx.com/api-reference/integration-secrets/create-a-secret)
-   * for you API key, pass the secret's `identifier` in this field.
-   */
-  api_key_ref?: string;
-
-  /**
-   * This is used with `use_beam_search` to determine how many candidate beams to
-   * explore.
-   */
-  best_of?: number;
-
-  /**
-   * This is used with `use_beam_search`. If `true`, generation stops as soon as
-   * there are `best_of` complete candidates; if `false`, a heuristic is applied and
-   * the generation stops when is it very unlikely to find better candidates.
-   */
-  early_stopping?: boolean;
-
-  /**
-   * Whether to enable the thinking/reasoning phase for models that support it (e.g.,
-   * QwQ, Qwen3). When set to false, the model will skip the internal reasoning step
-   * and respond directly, which can reduce latency. Defaults to true.
-   */
-  enable_thinking?: boolean;
-
-  /**
-   * Higher values will penalize the model from repeating the same output tokens.
-   */
-  frequency_penalty?: number;
-
-  /**
-   * If specified, the output will be exactly one of the choices.
-   */
-  guided_choice?: Array<string>;
-
-  /**
-   * Must be a valid JSON schema. If specified, the output will follow the JSON
-   * schema.
-   */
-  guided_json?: { [key: string]: unknown };
-
-  /**
-   * If specified, the output will follow the regex pattern.
-   */
-  guided_regex?: string;
-
-  /**
-   * This is used with `use_beam_search` to prefer shorter or longer completions.
-   */
-  length_penalty?: number;
-
-  /**
-   * Whether to return log probabilities of the output tokens or not. If true,
-   * returns the log probabilities of each output token returned in the `content` of
-   * `message`.
-   */
-  logprobs?: boolean;
-
-  /**
-   * Maximum number of completion tokens the model should generate.
-   */
-  max_tokens?: number;
-
-  /**
-   * This is an alternative to `top_p` that
-   * [many prefer](https://github.com/huggingface/transformers/issues/27670). Must be
-   * in [0, 1].
-   */
-  min_p?: number;
-
-  /**
-   * The language model to chat with.
-   */
-  model?: string;
-
-  /**
-   * This will return multiple choices for you instead of a single chat completion.
-   */
-  n?: number;
-
-  /**
-   * Higher values will penalize the model from repeating the same output tokens.
-   */
-  presence_penalty?: number;
-
-  /**
-   * Use this is you want to guarantee a JSON output without defining a schema. For
-   * control over the schema, use `guided_json`.
-   */
-  response_format?: ChatCreateCompletionParams.ResponseFormat;
-
-  /**
-   * If specified, the system will make a best effort to sample deterministically,
-   * such that repeated requests with the same `seed` and parameters should return
-   * the same result.
-   */
-  seed?: number;
-
-  /**
-   * Up to 4 sequences where the API will stop generating further tokens. The
-   * returned text will not contain the stop sequence.
-   */
-  stop?: string | Array<string>;
-
-  /**
-   * Whether or not to stream data-only server-sent events as they become available.
-   */
-  stream?: boolean;
-
-  /**
-   * Adjusts the "creativity" of the model. Lower values make the model more
-   * deterministic and repetitive, while higher values make the model more random and
-   * creative.
-   */
-  temperature?: number;
-
-  tool_choice?: 'none' | 'auto' | 'required';
-
-  /**
-   * The `function` tool type follows the same schema as the
-   * [OpenAI Chat Completions API](https://platform.openai.com/docs/api-reference/chat).
-   * The `retrieval` tool type is unique to Telnyx. You may pass a list of
-   * [embedded storage buckets](https://developers.telnyx.com/api-reference/embeddings/embed-documents)
-   * for retrieval-augmented generation.
-   */
-  tools?: Array<ChatCreateCompletionParams.Function | ChatCreateCompletionParams.Retrieval>;
-
-  /**
-   * This is used with `logprobs`. An integer between 0 and 20 specifying the number
-   * of most likely tokens to return at each token position, each with an associated
-   * log probability.
-   */
-  top_logprobs?: number;
-
-  /**
-   * An alternative or complement to `temperature`. This adjusts how many of the top
-   * possibilities to consider.
-   */
-  top_p?: number;
-
-  /**
-   * Setting this to `true` will allow the model to
-   * [explore more completion options](https://huggingface.co/blog/how-to-generate#beam-search).
-   * This is not supported by OpenAI.
-   */
-  use_beam_search?: boolean;
-}
-
-export namespace ChatCreateCompletionParams {
-  export interface Message {
-    content: string | Array<Message.TextAndImageArray>;
-
-    role: 'system' | 'user' | 'assistant' | 'tool';
-  }
-
-  export namespace Message {
-    export interface TextAndImageArray {
-      type: 'text' | 'image_url';
-
-      image_url?: string;
-
-      text?: string;
-    }
-  }
-
-  /**
-   * Use this is you want to guarantee a JSON output without defining a schema. For
-   * control over the schema, use `guided_json`.
-   */
-  export interface ResponseFormat {
-    type: 'text' | 'json_object';
-  }
-
-  export interface Function {
-    function: Function.Function;
-
-    type: 'function';
-  }
-
-  export namespace Function {
-    export interface Function {
-      name: string;
-
-      description?: string;
-
-      parameters?: { [key: string]: unknown };
-    }
-  }
-
-  export interface Retrieval {
-    retrieval: ChatAPI.BucketIDs;
-
-    type: 'retrieval';
-  }
-}
-
 export declare namespace Chat {
-  export {
-    type BucketIDs as BucketIDs,
-    type ChatCompletionRequest as ChatCompletionRequest,
-    type ChatCreateCompletionResponse as ChatCreateCompletionResponse,
-    type ChatCreateCompletionParams as ChatCreateCompletionParams,
-  };
+  export { type BucketIDs as BucketIDs, type ChatCompletionRequest as ChatCompletionRequest };
 }

package/src/resources/ai/conversations/conversation-insights.ts

@@ -0,0 +1,125 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+
+/**
+ * Manage historical AI assistant conversations
+ */
+export class ConversationInsights extends APIResource {
+  /**
+   * Aggregate conversation insights by specified fields
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.ai.conversations.conversationInsights.retrieveAggregates();
+   * ```
+   */
+  retrieveAggregates(
+    query: ConversationInsightRetrieveAggregatesParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ConversationInsightRetrieveAggregatesResponse> {
+    return this._client.get('/ai/conversations/conversation-insights/aggregates', { query, ...options });
+  }
+}
+
+/**
+ * Aggregated conversation insight counts grouped by the specified fields. Each
+ * item in `data` contains the grouped field values and a `record_count` indicating
+ * how many conversation insights match that combination.
+ */
+export interface ConversationInsightRetrieveAggregatesResponse {
+  /**
+   * Aggregation result rows. Each row contains the grouped field values and a
+   * `record_count`.
+   */
+  data: Array<ConversationInsightRetrieveAggregatesResponse.Data>;
+}
+
+export namespace ConversationInsightRetrieveAggregatesResponse {
+  /**
+   * An aggregation row. Contains the grouped field values (keyed by the group_by
+   * field names) and a `record_count` integer. For example, when grouping by
+   * `score`, each row has a `score` value and a `record_count` of conversations with
+   * that score. When also splitting by `metadata.assistant_version_id`, each row
+   * includes both `score` and `metadata.assistant_version_id` plus their combined
+   * `record_count`.
+   */
+  export interface Data {
+    /**
+     * Number of conversation insights that match this combination of grouped field
+     * values.
+     */
+    record_count: number;
+
+    [k: string]: unknown;
+  }
+}
+
+export interface ConversationInsightRetrieveAggregatesParams {
+  /**
+   * Filter by creation datetime to scope the aggregation window. Supports range
+   * operators (e.g., `created_at=gte.2025-01-01T00:00:00Z` for the start of the
+   * range, `created_at=lt.2025-01-02T00:00:00Z` for the end). To build per-day time
+   * series (as the portal does for the 'Insights Over Time' chart), issue one
+   * request per day bounded by `created_at=gte.<day_start>` and
+   * `created_at=lt.<next_day_start>`.
+   */
+  created_at?: string;
+
+  /**
+   * Fields to group by (can be comma-separated or multiple parameters). Prefix a
+   * field with 'metadata.' (e.g. 'metadata.assistant_id') to group by the
+   * conversation's metadata instead of the insight result.
+   *
+   * Common fields used for over-time charts:
+   *
+   * - `score` — Group by the insight's score value (e.g. for Agent Instruction
+   *   Following, User Satisfaction).
+   * - `metadata.assistant_id` — Group by the assistant that handled the
+   *   conversation.
+   * - `metadata.assistant_version_id` — Group by the assistant version, useful for
+   *   comparing performance across versions in the portal's 'Insights Over Time'
+   *   chart.
+   * - `metadata.telnyx_conversation_channel` — Group by conversation channel
+   *   (phone_call, web_chat, etc.).
+   */
+  group_by?: Array<string>;
+
+  /**
+   * Optional insight ID to filter conversation insights. Only insights matching this
+   * ID will be included in the aggregation.
+   */
+  insight_id?: string;
+
+  metadata?: ConversationInsightRetrieveAggregatesParams.Metadata;
+
+  /**
+   * Fields to include in the result (can be comma-separated or multiple parameters).
+   * Supports the same 'metadata.<key>' prefix as group_by. Each returned row will
+   * contain the grouped field values plus a `record_count` indicating how many
+   * conversation insights match that combination.
+   */
+  show?: Array<string>;
+}
+
+export namespace ConversationInsightRetrieveAggregatesParams {
+  export interface Metadata {
+    /**
+     * Filter by assistant ID (e.g., `metadata.assistant_id=eq.<assistant_id>`). When
+     * provided, only conversation insights for the specified assistant are aggregated.
+     * Used by the portal to scope the 'Insights Over Time' chart to a single
+     * assistant.
+     */
+    assistant_id?: string;
+  }
+}
+
+export declare namespace ConversationInsights {
+  export {
+    type ConversationInsightRetrieveAggregatesResponse as ConversationInsightRetrieveAggregatesResponse,
+    type ConversationInsightRetrieveAggregatesParams as ConversationInsightRetrieveAggregatesParams,
+  };
+}

package/src/resources/ai/conversations/conversations.ts

@@ -1,6 +1,12 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../../../core/resource';
+import * as ConversationInsightsAPI from './conversation-insights';
+import {
+  ConversationInsightRetrieveAggregatesParams,
+  ConversationInsightRetrieveAggregatesResponse,
+  ConversationInsights,
+} from './conversation-insights';
 import * as InsightsAPI from './insights';
 import {
   InsightCreateParams,
@@ -41,6 +47,8 @@ export class Conversations extends APIResource {
   insightGroups: InsightGroupsAPI.InsightGroups = new InsightGroupsAPI.InsightGroups(this._client);
   insights: InsightsAPI.Insights = new InsightsAPI.Insights(this._client);
   messages: MessagesAPI.Messages = new MessagesAPI.Messages(this._client);
+  conversationInsights: ConversationInsightsAPI.ConversationInsights =
+    new ConversationInsightsAPI.ConversationInsights(this._client);
 
   /**
    * Retrieve a list of all AI conversations configured by the user. Supports
@@ -354,6 +362,7 @@ export interface ConversationAddMessageParams {
 Conversations.InsightGroups = InsightGroups;
 Conversations.Insights = Insights;
 Conversations.Messages = Messages;
+Conversations.ConversationInsights = ConversationInsights;
 
 export declare namespace Conversations {
   export {
@@ -394,4 +403,10 @@ export declare namespace Conversations {
     type MessageListResponsesDefaultFlatPagination as MessageListResponsesDefaultFlatPagination,
     type MessageListParams as MessageListParams,
   };
+
+  export {
+    ConversationInsights as ConversationInsights,
+    type ConversationInsightRetrieveAggregatesResponse as ConversationInsightRetrieveAggregatesResponse,
+    type ConversationInsightRetrieveAggregatesParams as ConversationInsightRetrieveAggregatesParams,
+  };
 }