@orq-ai/node 4.5.0-rc.26 → 4.5.0-rc.33

package/models/operations/listagents.d.ts

@@ -3,6 +3,17 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+/**
+ * Filter agents by type: "internal" for Orquesta-managed agents, "a2a" for external A2A-compliant agents
+ */
+export declare const QueryParamType: {
+    readonly Internal: "internal";
+    readonly A2a: "a2a";
+};
+/**
+ * Filter agents by type: "internal" for Orquesta-managed agents, "a2a" for external A2A-compliant agents
+ */
+export type QueryParamType = ClosedEnum<typeof QueryParamType>;
 export type ListAgentsRequest = {
     /**
      * A limit on the number of objects to be returned. Limit can range between 1 and 200. When not provided, returns all agents without pagination.
@@ -16,6 +27,10 @@ export type ListAgentsRequest = {
      * A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, starting with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `before=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the previous page of the list.
      */
     endingBefore?: string | undefined;
+    /**
+     * Filter agents by type: "internal" for Orquesta-managed agents, "a2a" for external A2A-compliant agents
+     */
+    type?: QueryParamType | undefined;
 };
 export declare const ListAgentsObject: {
     readonly List: "list";
@@ -24,7 +39,7 @@ export type ListAgentsObject = ClosedEnum<typeof ListAgentsObject>;
 /**
  * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
  */
-export declare const ListAgentsStatus: {
+export declare const ListAgentsDataStatus: {
     readonly Live: "live";
     readonly Draft: "draft";
     readonly Pending: "pending";
@@ -33,11 +48,172 @@ export declare const ListAgentsStatus: {
 /**
  * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
  */
-export type ListAgentsStatus = ClosedEnum<typeof ListAgentsStatus>;
+export type ListAgentsDataStatus = ClosedEnum<typeof ListAgentsDataStatus>;
+export type ListAgentsDataTeamOfAgents = {
+    /**
+     * The unique key of the agent within the workspace
+     */
+    key: string;
+    /**
+     * The role of the agent in this context. This is used to give extra information to the leader to help it decide which agent to hand off to.
+     */
+    role?: string | undefined;
+};
+export type ListAgentsDataMetrics = {
+    totalCost: number;
+};
+export type ListAgentsDataKnowledgeBases = {
+    /**
+     * Unique identifier of the knowledge base to search
+     */
+    knowledgeId: string;
+};
+export declare const ListAgentsDataSource: {
+    readonly Internal: "internal";
+    readonly External: "external";
+    readonly Experiment: "experiment";
+};
+export type ListAgentsDataSource = ClosedEnum<typeof ListAgentsDataSource>;
+export type DataHeaders = {
+    /**
+     * Header value. **Update behavior**: Provide empty string ("") to preserve existing encrypted value without re-entering credentials. Provide new value to rotate. Omit header entirely to remove.
+     */
+    value: string;
+    encrypted: boolean;
+};
+/**
+ * A2A configuration with agent endpoint and authentication. External agents manage their own model/settings.
+ */
+export type DataA2AAgentConfiguration = {
+    /**
+     * The A2A agent endpoint URL (e.g., https://example.com/agent/a2a)
+     */
+    agentUrl: string;
+    /**
+     * Optional explicit URL to fetch agent card. Defaults to {agent_url}/card if not provided
+     */
+    cardUrl?: string | undefined;
+    /**
+     * HTTP headers for A2A agent requests with encryption support (max 20 headers). **Update behavior**: Empty string values preserve existing encrypted headers, allowing partial updates without credential re-entry.
+     */
+    headers?: {
+        [k: string]: DataHeaders;
+    } | undefined;
+    /**
+     * Cached agent card from discovery. Refreshed periodically.
+     */
+    cachedCard?: any | undefined;
+};
+export type Data2 = {
+    id: string;
+    /**
+     * Unique identifier for the agent within the workspace
+     */
+    key: string;
+    displayName?: string | undefined;
+    createdById?: string | null | undefined;
+    updatedById?: string | null | undefined;
+    created?: string | undefined;
+    updated?: string | undefined;
+    /**
+     * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
+     */
+    status: ListAgentsDataStatus;
+    versionHash?: string | undefined;
+    /**
+     * Entity storage path in the format: `project/folder/subfolder/...`
+     *
+     * @remarks
+     *
+     * The first element identifies the project, followed by nested folders (auto-created as needed).
+     *
+     * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
+     */
+    path: string;
+    /**
+     * Array of memory store identifiers. Accepts both memory store IDs and keys.
+     */
+    memoryStores?: Array<string> | undefined;
+    /**
+     * The agents that are accessible to this orchestrator. The main agent can hand off to these agents to perform tasks.
+     */
+    teamOfAgents?: Array<ListAgentsDataTeamOfAgents> | undefined;
+    metrics?: ListAgentsDataMetrics | undefined;
+    /**
+     * Extracted variables from agent instructions
+     */
+    variables?: {
+        [k: string]: any;
+    } | undefined;
+    /**
+     * Agent knowledge bases reference
+     */
+    knowledgeBases?: Array<ListAgentsDataKnowledgeBases> | undefined;
+    source?: ListAgentsDataSource | undefined;
+    /**
+     * External A2A-compliant agent
+     */
+    type: "a2a";
+    /**
+     * Role fetched from agent card name or user-provided
+     */
+    role: string;
+    /**
+     * Description fetched from agent card or user-provided
+     */
+    description: string;
+    systemPrompt?: string | undefined;
+    /**
+     * Instructions from agent card description or user-provided
+     */
+    instructions: string;
+    /**
+     * A2A configuration with agent endpoint and authentication. External agents manage their own model/settings.
+     */
+    a2a: DataA2AAgentConfiguration;
+};
+/**
+ * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
+ */
+export declare const DataStatus: {
+    readonly Live: "live";
+    readonly Draft: "draft";
+    readonly Pending: "pending";
+    readonly Published: "published";
+};
+/**
+ * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
+ */
+export type DataStatus = ClosedEnum<typeof DataStatus>;
+export type DataTeamOfAgents = {
+    /**
+     * The unique key of the agent within the workspace
+     */
+    key: string;
+    /**
+     * The role of the agent in this context. This is used to give extra information to the leader to help it decide which agent to hand off to.
+     */
+    role?: string | undefined;
+};
+export type DataMetrics = {
+    totalCost: number;
+};
+export type DataKnowledgeBases = {
+    /**
+     * Unique identifier of the knowledge base to search
+     */
+    knowledgeId: string;
+};
+export declare const DataSource: {
+    readonly Internal: "internal";
+    readonly External: "external";
+    readonly Experiment: "experiment";
+};
+export type DataSource = ClosedEnum<typeof DataSource>;
 /**
  * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
  */
-export declare const ListAgentsToolApprovalRequired: {
+export declare const DataToolApprovalRequired: {
     readonly All: "all";
     readonly RespectTool: "respect_tool";
     readonly None: "none";
@@ -45,8 +221,8 @@ export declare const ListAgentsToolApprovalRequired: {
 /**
  * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
  */
-export type ListAgentsToolApprovalRequired = ClosedEnum<typeof ListAgentsToolApprovalRequired>;
-export type ListAgentsConditions = {
+export type DataToolApprovalRequired = ClosedEnum<typeof DataToolApprovalRequired>;
+export type DataConditions = {
     /**
      * The argument of the tool call to evaluate
      */
@@ -60,7 +236,7 @@ export type ListAgentsConditions = {
      */
     value: string;
 };
-export type ListAgentsTools = {
+export type DataTools = {
     /**
      * The id of the resource
      */
@@ -80,7 +256,7 @@ export type ListAgentsTools = {
      * Nested tool ID for MCP tools (identifies specific tool within MCP server)
      */
     toolId?: string | undefined;
-    conditions?: Array<ListAgentsConditions> | undefined;
+    conditions?: Array<DataConditions> | undefined;
     /**
      * Tool execution timeout in seconds (default: 2 minutes, max: 10 minutes)
      */
@@ -89,15 +265,15 @@ export type ListAgentsTools = {
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export declare const ListAgentsExecuteOn: {
+export declare const DataExecuteOn: {
     readonly Input: "input";
     readonly Output: "output";
 };
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export type ListAgentsExecuteOn = ClosedEnum<typeof ListAgentsExecuteOn>;
-export type ListAgentsEvaluators = {
+export type DataExecuteOn = ClosedEnum<typeof DataExecuteOn>;
+export type DataEvaluators = {
     /**
      * Unique key or identifier of the evaluator
      */
@@ -109,20 +285,20 @@ export type ListAgentsEvaluators = {
     /**
      * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
      */
-    executeOn: ListAgentsExecuteOn;
+    executeOn: DataExecuteOn;
 };
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export declare const ListAgentsAgentsExecuteOn: {
+export declare const ListAgentsDataExecuteOn: {
     readonly Input: "input";
     readonly Output: "output";
 };
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export type ListAgentsAgentsExecuteOn = ClosedEnum<typeof ListAgentsAgentsExecuteOn>;
-export type ListAgentsGuardrails = {
+export type ListAgentsDataExecuteOn = ClosedEnum<typeof ListAgentsDataExecuteOn>;
+export type DataGuardrails = {
     /**
      * Unique key or identifier of the evaluator
      */
@@ -134,9 +310,9 @@ export type ListAgentsGuardrails = {
     /**
      * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
      */
-    executeOn: ListAgentsAgentsExecuteOn;
+    executeOn: ListAgentsDataExecuteOn;
 };
-export type ListAgentsSettings = {
+export type DataSettings = {
     /**
      * Maximum iterations(llm calls) before the agent will stop executing.
      */
@@ -152,16 +328,16 @@ export type ListAgentsSettings = {
     /**
      * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
      */
-    toolApprovalRequired: ListAgentsToolApprovalRequired;
-    tools?: Array<ListAgentsTools> | undefined;
+    toolApprovalRequired: DataToolApprovalRequired;
+    tools?: Array<DataTools> | undefined;
     /**
      * Configuration for an evaluator applied to the agent
      */
-    evaluators?: Array<ListAgentsEvaluators> | undefined;
+    evaluators?: Array<DataEvaluators> | undefined;
     /**
      * Configuration for a guardrail applied to the agent
      */
-    guardrails?: Array<ListAgentsGuardrails> | undefined;
+    guardrails?: Array<DataGuardrails> | undefined;
 };
 export type ListAgentsResponseFormatJsonSchema = {
     /**
@@ -209,7 +385,7 @@ export type ListAgentsResponseFormatText = {
 /**
  * An object specifying the format that the model must output
  */
-export type ListAgentsResponseFormat = ListAgentsResponseFormatText | ListAgentsResponseFormatJSONObject | ListAgentsResponseFormatAgentsJSONSchema;
+export type DataResponseFormat = ListAgentsResponseFormatText | ListAgentsResponseFormatJSONObject | ListAgentsResponseFormatAgentsJSONSchema;
 /**
  * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
  *
@@ -222,7 +398,7 @@ export type ListAgentsResponseFormat = ListAgentsResponseFormatText | ListAgents
  *
  * Any of "none", "minimal", "low", "medium", "high", "xhigh".
  */
-export declare const ListAgentsReasoningEffort: {
+export declare const DataReasoningEffort: {
     readonly None: "none";
     readonly Minimal: "minimal";
     readonly Low: "low";
@@ -242,12 +418,12 @@ export declare const ListAgentsReasoningEffort: {
  *
  * Any of "none", "minimal", "low", "medium", "high", "xhigh".
  */
-export type ListAgentsReasoningEffort = ClosedEnum<typeof ListAgentsReasoningEffort>;
+export type DataReasoningEffort = ClosedEnum<typeof DataReasoningEffort>;
 /**
  * Up to 4 sequences where the API will stop generating further tokens.
  */
-export type ListAgentsStop = string | Array<string>;
-export type ListAgentsThinking = components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema;
+export type DataStop = string | Array<string>;
+export type DataThinking = components.ThinkingConfigDisabledSchema | components.ThinkingConfigEnabledSchema;
 /**
  * The type of the tool. Currently, only function is supported.
  */
@@ -280,12 +456,12 @@ export type ListAgentsToolChoice1 = ClosedEnum<typeof ListAgentsToolChoice1>;
 /**
  * Controls which (if any) tool is called by the model.
  */
-export type ListAgentsToolChoice = ListAgentsToolChoice2 | ListAgentsToolChoice1;
-export declare const ListAgentsModalities: {
+export type DataToolChoice = ListAgentsToolChoice2 | ListAgentsToolChoice1;
+export declare const DataModalities: {
     readonly Text: "text";
     readonly Audio: "audio";
 };
-export type ListAgentsModalities = ClosedEnum<typeof ListAgentsModalities>;
+export type DataModalities = ClosedEnum<typeof DataModalities>;
 /**
  * The key of the guardrail.
  */
@@ -298,44 +474,44 @@ export declare const ListAgentsId1: {
  * The key of the guardrail.
  */
 export type ListAgentsId1 = ClosedEnum<typeof ListAgentsId1>;
-export type ListAgentsId = ListAgentsId1 | string;
+export type DataId = ListAgentsId1 | string;
 /**
  * Determines whether the guardrail runs on the input (user message) or output (model response).
  */
-export declare const ListAgentsAgentsResponseExecuteOn: {
+export declare const ListAgentsDataAgentsExecuteOn: {
     readonly Input: "input";
     readonly Output: "output";
 };
 /**
  * Determines whether the guardrail runs on the input (user message) or output (model response).
  */
-export type ListAgentsAgentsResponseExecuteOn = ClosedEnum<typeof ListAgentsAgentsResponseExecuteOn>;
-export type ListAgentsAgentsGuardrails = {
+export type ListAgentsDataAgentsExecuteOn = ClosedEnum<typeof ListAgentsDataAgentsExecuteOn>;
+export type ListAgentsDataGuardrails = {
     id: ListAgentsId1 | string;
     /**
      * Determines whether the guardrail runs on the input (user message) or output (model response).
      */
-    executeOn: ListAgentsAgentsResponseExecuteOn;
+    executeOn: ListAgentsDataAgentsExecuteOn;
 };
-export type ListAgentsFallbacks = {
+export type DataFallbacks = {
     /**
      * Fallback model identifier
      */
     model: string;
 };
-export declare const ListAgentsType: {
+export declare const ListAgentsDataAgentsResponseType: {
     readonly ExactMatch: "exact_match";
 };
-export type ListAgentsType = ClosedEnum<typeof ListAgentsType>;
+export type ListAgentsDataAgentsResponseType = ClosedEnum<typeof ListAgentsDataAgentsResponseType>;
 /**
  * Cache configuration for the request.
  */
-export type ListAgentsCache = {
+export type DataCache = {
     /**
      * Time to live for cached responses in seconds. Maximum 259200 seconds (3 days).
      */
     ttl: number;
-    type: ListAgentsType;
+    type: ListAgentsDataAgentsResponseType;
 };
 export declare const ListAgentsLoadBalancerType: {
     readonly WeightBased: "weight_based";
@@ -358,11 +534,11 @@ export type ListAgentsLoadBalancer1 = {
 /**
  * Load balancer configuration for the request.
  */
-export type ListAgentsLoadBalancer = ListAgentsLoadBalancer1;
+export type DataLoadBalancer = ListAgentsLoadBalancer1;
 /**
  * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
  */
-export type ListAgentsTimeout = {
+export type DataTimeout = {
     /**
      * Timeout value in milliseconds
      */
@@ -371,7 +547,7 @@ export type ListAgentsTimeout = {
 /**
  * Model behavior parameters (snake_case) stored as part of the agent configuration. These become the default parameters used when the agent is executed. Commonly used: temperature (0-1, controls randomness), max_completion_tokens (response length), top_p (nucleus sampling). Advanced: frequency_penalty, presence_penalty, response_format (JSON/structured output), reasoning_effort (for o1/thinking models), seed (reproducibility), stop sequences. Model-specific support varies. Runtime parameters in agent execution requests can override these defaults.
  */
-export type ListAgentsParameters = {
+export type DataParameters = {
     /**
      * The name to display on the trace. If not specified, the default system name will be used.
      */
@@ -412,7 +588,7 @@ export type ListAgentsParameters = {
      *
      * Any of "none", "minimal", "low", "medium", "high", "xhigh".
      */
-    reasoningEffort?: ListAgentsReasoningEffort | undefined;
+    reasoningEffort?: DataReasoningEffort | undefined;
     /**
      * Adjusts response verbosity. Lower levels yield shorter answers.
      */
@@ -449,19 +625,19 @@ export type ListAgentsParameters = {
     /**
      * Output types that you would like the model to generate. Most models are capable of generating text, which is the default: ["text"]. The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: ["text", "audio"].
      */
-    modalities?: Array<ListAgentsModalities> | null | undefined;
+    modalities?: Array<DataModalities> | null | undefined;
     /**
      * A list of guardrails to apply to the request.
      */
-    guardrails?: Array<ListAgentsAgentsGuardrails> | undefined;
+    guardrails?: Array<ListAgentsDataGuardrails> | undefined;
     /**
      * Array of fallback models to use if primary model fails
      */
-    fallbacks?: Array<ListAgentsFallbacks> | undefined;
+    fallbacks?: Array<DataFallbacks> | undefined;
     /**
      * Cache configuration for the request.
      */
-    cache?: ListAgentsCache | undefined;
+    cache?: DataCache | undefined;
     /**
      * Load balancer configuration for the request.
      */
@@ -469,12 +645,12 @@ export type ListAgentsParameters = {
     /**
      * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
      */
-    timeout?: ListAgentsTimeout | undefined;
+    timeout?: DataTimeout | undefined;
 };
 /**
  * Retry configuration for model requests. Allows customizing retry count (1-5) and HTTP status codes that trigger retries. Default codes: [429]. Common codes: 500 (internal error), 429 (rate limit), 502/503/504 (gateway errors).
  */
-export type ListAgentsRetry = {
+export type DataRetry = {
     /**
      * Number of retry attempts (1-5)
      */
@@ -825,8 +1001,8 @@ export type ListAgentsFallbackModelConfiguration2 = {
 /**
  * Fallback model for automatic failover when primary model request fails. Supports optional parameter overrides. Can be a simple model ID string or a configuration object with model-specific parameters. Fallbacks are tried in order.
  */
-export type ListAgentsFallbackModelConfiguration = ListAgentsFallbackModelConfiguration2 | string;
-export type ListAgentsModel = {
+export type DataFallbackModelConfiguration = ListAgentsFallbackModelConfiguration2 | string;
+export type DataModel = {
     /**
      * The database ID of the primary model
      */
@@ -838,42 +1014,17 @@ export type ListAgentsModel = {
     /**
      * Model behavior parameters (snake_case) stored as part of the agent configuration. These become the default parameters used when the agent is executed. Commonly used: temperature (0-1, controls randomness), max_completion_tokens (response length), top_p (nucleus sampling). Advanced: frequency_penalty, presence_penalty, response_format (JSON/structured output), reasoning_effort (for o1/thinking models), seed (reproducibility), stop sequences. Model-specific support varies. Runtime parameters in agent execution requests can override these defaults.
      */
-    parameters?: ListAgentsParameters | undefined;
+    parameters?: DataParameters | undefined;
     /**
      * Retry configuration for model requests. Allows customizing retry count (1-5) and HTTP status codes that trigger retries. Default codes: [429]. Common codes: 500 (internal error), 429 (rate limit), 502/503/504 (gateway errors).
      */
-    retry?: ListAgentsRetry | undefined;
+    retry?: DataRetry | undefined;
     /**
      * Optional array of fallback models (string IDs or config objects) that will be used automatically in order if the primary model fails
      */
     fallbackModels?: Array<ListAgentsFallbackModelConfiguration2 | string> | null | undefined;
 };
-export type ListAgentsTeamOfAgents = {
-    /**
-     * The unique key of the agent within the workspace
-     */
-    key: string;
-    /**
-     * The role of the agent in this context. This is used to give extra information to the leader to help it decide which agent to hand off to.
-     */
-    role?: string | undefined;
-};
-export type ListAgentsMetrics = {
-    totalCost: number;
-};
-export type ListAgentsKnowledgeBases = {
-    /**
-     * Unique identifier of the knowledge base to search
-     */
-    knowledgeId: string;
-};
-export declare const ListAgentsSource: {
-    readonly Internal: "internal";
-    readonly External: "external";
-    readonly Experiment: "experiment";
-};
-export type ListAgentsSource = ClosedEnum<typeof ListAgentsSource>;
-export type ListAgentsData = {
+export type Data1 = {
     id: string;
     /**
      * Unique identifier for the agent within the workspace
@@ -884,16 +1035,10 @@ export type ListAgentsData = {
     updatedById?: string | null | undefined;
     created?: string | undefined;
     updated?: string | undefined;
-    role: string;
-    description: string;
-    systemPrompt?: string | undefined;
-    instructions: string;
     /**
      * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
      */
-    status: ListAgentsStatus;
-    settings?: ListAgentsSettings | undefined;
-    model: ListAgentsModel;
+    status: DataStatus;
     versionHash?: string | undefined;
     /**
      * Entity storage path in the format: `project/folder/subfolder/...`
@@ -908,12 +1053,12 @@ export type ListAgentsData = {
     /**
      * Array of memory store identifiers. Accepts both memory store IDs and keys.
      */
-    memoryStores: Array<string>;
+    memoryStores?: Array<string> | undefined;
     /**
      * The agents that are accessible to this orchestrator. The main agent can hand off to these agents to perform tasks.
      */
-    teamOfAgents: Array<ListAgentsTeamOfAgents>;
-    metrics?: ListAgentsMetrics | undefined;
+    teamOfAgents?: Array<DataTeamOfAgents> | undefined;
+    metrics?: DataMetrics | undefined;
     /**
      * Extracted variables from agent instructions
      */
@@ -923,22 +1068,36 @@ export type ListAgentsData = {
     /**
      * Agent knowledge bases reference
      */
-    knowledgeBases?: Array<ListAgentsKnowledgeBases> | undefined;
-    source?: ListAgentsSource | undefined;
+    knowledgeBases?: Array<DataKnowledgeBases> | undefined;
+    source?: DataSource | undefined;
+    /**
+     * Orquesta-managed agent
+     */
+    type: "internal";
+    role: string;
+    description: string;
+    systemPrompt?: string | undefined;
+    instructions: string;
+    settings?: DataSettings | undefined;
+    model: DataModel;
 };
+export type ListAgentsData = Data1 | Data2;
 /**
  * Successfully retrieved the list of agents. Returns a paginated response containing agent manifests with complete configurations, including primary and fallback models, tools, knowledge bases, and execution settings.
  */
 export type ListAgentsResponseBody = {
     object: ListAgentsObject;
-    data: Array<ListAgentsData>;
+    data: Array<Data1 | Data2>;
     hasMore: boolean;
 };
 /** @internal */
+export declare const QueryParamType$outboundSchema: z.ZodNativeEnum<typeof QueryParamType>;
+/** @internal */
 export type ListAgentsRequest$Outbound = {
     limit?: number | undefined;
     starting_after?: string | undefined;
     ending_before?: string | undefined;
+    type?: string | undefined;
 };
 /** @internal */
 export declare const ListAgentsRequest$outboundSchema: z.ZodType<ListAgentsRequest$Outbound, z.ZodTypeDef, ListAgentsRequest>;
@@ -946,28 +1105,61 @@ export declare function listAgentsRequestToJSON(listAgentsRequest: ListAgentsReq
 /** @internal */
 export declare const ListAgentsObject$inboundSchema: z.ZodNativeEnum<typeof ListAgentsObject>;
 /** @internal */
-export declare const ListAgentsStatus$inboundSchema: z.ZodNativeEnum<typeof ListAgentsStatus>;
+export declare const ListAgentsDataStatus$inboundSchema: z.ZodNativeEnum<typeof ListAgentsDataStatus>;
+/** @internal */
+export declare const ListAgentsDataTeamOfAgents$inboundSchema: z.ZodType<ListAgentsDataTeamOfAgents, z.ZodTypeDef, unknown>;
+export declare function listAgentsDataTeamOfAgentsFromJSON(jsonString: string): SafeParseResult<ListAgentsDataTeamOfAgents, SDKValidationError>;
+/** @internal */
+export declare const ListAgentsDataMetrics$inboundSchema: z.ZodType<ListAgentsDataMetrics, z.ZodTypeDef, unknown>;
+export declare function listAgentsDataMetricsFromJSON(jsonString: string): SafeParseResult<ListAgentsDataMetrics, SDKValidationError>;
+/** @internal */
+export declare const ListAgentsDataKnowledgeBases$inboundSchema: z.ZodType<ListAgentsDataKnowledgeBases, z.ZodTypeDef, unknown>;
+export declare function listAgentsDataKnowledgeBasesFromJSON(jsonString: string): SafeParseResult<ListAgentsDataKnowledgeBases, SDKValidationError>;
+/** @internal */
+export declare const ListAgentsDataSource$inboundSchema: z.ZodNativeEnum<typeof ListAgentsDataSource>;
+/** @internal */
+export declare const DataHeaders$inboundSchema: z.ZodType<DataHeaders, z.ZodTypeDef, unknown>;
+export declare function dataHeadersFromJSON(jsonString: string): SafeParseResult<DataHeaders, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsToolApprovalRequired$inboundSchema: z.ZodNativeEnum<typeof ListAgentsToolApprovalRequired>;
+export declare const DataA2AAgentConfiguration$inboundSchema: z.ZodType<DataA2AAgentConfiguration, z.ZodTypeDef, unknown>;
+export declare function dataA2AAgentConfigurationFromJSON(jsonString: string): SafeParseResult<DataA2AAgentConfiguration, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsConditions$inboundSchema: z.ZodType<ListAgentsConditions, z.ZodTypeDef, unknown>;
-export declare function listAgentsConditionsFromJSON(jsonString: string): SafeParseResult<ListAgentsConditions, SDKValidationError>;
+export declare const Data2$inboundSchema: z.ZodType<Data2, z.ZodTypeDef, unknown>;
+export declare function data2FromJSON(jsonString: string): SafeParseResult<Data2, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsTools$inboundSchema: z.ZodType<ListAgentsTools, z.ZodTypeDef, unknown>;
-export declare function listAgentsToolsFromJSON(jsonString: string): SafeParseResult<ListAgentsTools, SDKValidationError>;
+export declare const DataStatus$inboundSchema: z.ZodNativeEnum<typeof DataStatus>;
 /** @internal */
-export declare const ListAgentsExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ListAgentsExecuteOn>;
+export declare const DataTeamOfAgents$inboundSchema: z.ZodType<DataTeamOfAgents, z.ZodTypeDef, unknown>;
+export declare function dataTeamOfAgentsFromJSON(jsonString: string): SafeParseResult<DataTeamOfAgents, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsEvaluators$inboundSchema: z.ZodType<ListAgentsEvaluators, z.ZodTypeDef, unknown>;
-export declare function listAgentsEvaluatorsFromJSON(jsonString: string): SafeParseResult<ListAgentsEvaluators, SDKValidationError>;
+export declare const DataMetrics$inboundSchema: z.ZodType<DataMetrics, z.ZodTypeDef, unknown>;
+export declare function dataMetricsFromJSON(jsonString: string): SafeParseResult<DataMetrics, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsAgentsExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ListAgentsAgentsExecuteOn>;
+export declare const DataKnowledgeBases$inboundSchema: z.ZodType<DataKnowledgeBases, z.ZodTypeDef, unknown>;
+export declare function dataKnowledgeBasesFromJSON(jsonString: string): SafeParseResult<DataKnowledgeBases, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsGuardrails$inboundSchema: z.ZodType<ListAgentsGuardrails, z.ZodTypeDef, unknown>;
-export declare function listAgentsGuardrailsFromJSON(jsonString: string): SafeParseResult<ListAgentsGuardrails, SDKValidationError>;
+export declare const DataSource$inboundSchema: z.ZodNativeEnum<typeof DataSource>;
 /** @internal */
-export declare const ListAgentsSettings$inboundSchema: z.ZodType<ListAgentsSettings, z.ZodTypeDef, unknown>;
-export declare function listAgentsSettingsFromJSON(jsonString: string): SafeParseResult<ListAgentsSettings, SDKValidationError>;
+export declare const DataToolApprovalRequired$inboundSchema: z.ZodNativeEnum<typeof DataToolApprovalRequired>;
+/** @internal */
+export declare const DataConditions$inboundSchema: z.ZodType<DataConditions, z.ZodTypeDef, unknown>;
+export declare function dataConditionsFromJSON(jsonString: string): SafeParseResult<DataConditions, SDKValidationError>;
+/** @internal */
+export declare const DataTools$inboundSchema: z.ZodType<DataTools, z.ZodTypeDef, unknown>;
+export declare function dataToolsFromJSON(jsonString: string): SafeParseResult<DataTools, SDKValidationError>;
+/** @internal */
+export declare const DataExecuteOn$inboundSchema: z.ZodNativeEnum<typeof DataExecuteOn>;
+/** @internal */
+export declare const DataEvaluators$inboundSchema: z.ZodType<DataEvaluators, z.ZodTypeDef, unknown>;
+export declare function dataEvaluatorsFromJSON(jsonString: string): SafeParseResult<DataEvaluators, SDKValidationError>;
+/** @internal */
+export declare const ListAgentsDataExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ListAgentsDataExecuteOn>;
+/** @internal */
+export declare const DataGuardrails$inboundSchema: z.ZodType<DataGuardrails, z.ZodTypeDef, unknown>;
+export declare function dataGuardrailsFromJSON(jsonString: string): SafeParseResult<DataGuardrails, SDKValidationError>;
+/** @internal */
+export declare const DataSettings$inboundSchema: z.ZodType<DataSettings, z.ZodTypeDef, unknown>;
+export declare function dataSettingsFromJSON(jsonString: string): SafeParseResult<DataSettings, SDKValidationError>;
 /** @internal */
 export declare const ListAgentsResponseFormatJsonSchema$inboundSchema: z.ZodType<ListAgentsResponseFormatJsonSchema, z.ZodTypeDef, unknown>;
 export declare function listAgentsResponseFormatJsonSchemaFromJSON(jsonString: string): SafeParseResult<ListAgentsResponseFormatJsonSchema, SDKValidationError>;
@@ -981,16 +1173,16 @@ export declare function listAgentsResponseFormatJSONObjectFromJSON(jsonString: s
 export declare const ListAgentsResponseFormatText$inboundSchema: z.ZodType<ListAgentsResponseFormatText, z.ZodTypeDef, unknown>;
 export declare function listAgentsResponseFormatTextFromJSON(jsonString: string): SafeParseResult<ListAgentsResponseFormatText, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsResponseFormat$inboundSchema: z.ZodType<ListAgentsResponseFormat, z.ZodTypeDef, unknown>;
-export declare function listAgentsResponseFormatFromJSON(jsonString: string): SafeParseResult<ListAgentsResponseFormat, SDKValidationError>;
+export declare const DataResponseFormat$inboundSchema: z.ZodType<DataResponseFormat, z.ZodTypeDef, unknown>;
+export declare function dataResponseFormatFromJSON(jsonString: string): SafeParseResult<DataResponseFormat, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsReasoningEffort$inboundSchema: z.ZodNativeEnum<typeof ListAgentsReasoningEffort>;
+export declare const DataReasoningEffort$inboundSchema: z.ZodNativeEnum<typeof DataReasoningEffort>;
 /** @internal */
-export declare const ListAgentsStop$inboundSchema: z.ZodType<ListAgentsStop, z.ZodTypeDef, unknown>;
-export declare function listAgentsStopFromJSON(jsonString: string): SafeParseResult<ListAgentsStop, SDKValidationError>;
+export declare const DataStop$inboundSchema: z.ZodType<DataStop, z.ZodTypeDef, unknown>;
+export declare function dataStopFromJSON(jsonString: string): SafeParseResult<DataStop, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsThinking$inboundSchema: z.ZodType<ListAgentsThinking, z.ZodTypeDef, unknown>;
-export declare function listAgentsThinkingFromJSON(jsonString: string): SafeParseResult<ListAgentsThinking, SDKValidationError>;
+export declare const DataThinking$inboundSchema: z.ZodType<DataThinking, z.ZodTypeDef, unknown>;
+export declare function dataThinkingFromJSON(jsonString: string): SafeParseResult<DataThinking, SDKValidationError>;
 /** @internal */
 export declare const ListAgentsToolChoiceType$inboundSchema: z.ZodNativeEnum<typeof ListAgentsToolChoiceType>;
 /** @internal */
@@ -1002,28 +1194,28 @@ export declare function listAgentsToolChoice2FromJSON(jsonString: string): SafeP
 /** @internal */
 export declare const ListAgentsToolChoice1$inboundSchema: z.ZodNativeEnum<typeof ListAgentsToolChoice1>;
 /** @internal */
-export declare const ListAgentsToolChoice$inboundSchema: z.ZodType<ListAgentsToolChoice, z.ZodTypeDef, unknown>;
-export declare function listAgentsToolChoiceFromJSON(jsonString: string): SafeParseResult<ListAgentsToolChoice, SDKValidationError>;
+export declare const DataToolChoice$inboundSchema: z.ZodType<DataToolChoice, z.ZodTypeDef, unknown>;
+export declare function dataToolChoiceFromJSON(jsonString: string): SafeParseResult<DataToolChoice, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsModalities$inboundSchema: z.ZodNativeEnum<typeof ListAgentsModalities>;
+export declare const DataModalities$inboundSchema: z.ZodNativeEnum<typeof DataModalities>;
 /** @internal */
 export declare const ListAgentsId1$inboundSchema: z.ZodNativeEnum<typeof ListAgentsId1>;
 /** @internal */
-export declare const ListAgentsId$inboundSchema: z.ZodType<ListAgentsId, z.ZodTypeDef, unknown>;
-export declare function listAgentsIdFromJSON(jsonString: string): SafeParseResult<ListAgentsId, SDKValidationError>;
+export declare const DataId$inboundSchema: z.ZodType<DataId, z.ZodTypeDef, unknown>;
+export declare function dataIdFromJSON(jsonString: string): SafeParseResult<DataId, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsAgentsResponseExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ListAgentsAgentsResponseExecuteOn>;
+export declare const ListAgentsDataAgentsExecuteOn$inboundSchema: z.ZodNativeEnum<typeof ListAgentsDataAgentsExecuteOn>;
 /** @internal */
-export declare const ListAgentsAgentsGuardrails$inboundSchema: z.ZodType<ListAgentsAgentsGuardrails, z.ZodTypeDef, unknown>;
-export declare function listAgentsAgentsGuardrailsFromJSON(jsonString: string): SafeParseResult<ListAgentsAgentsGuardrails, SDKValidationError>;
+export declare const ListAgentsDataGuardrails$inboundSchema: z.ZodType<ListAgentsDataGuardrails, z.ZodTypeDef, unknown>;
+export declare function listAgentsDataGuardrailsFromJSON(jsonString: string): SafeParseResult<ListAgentsDataGuardrails, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsFallbacks$inboundSchema: z.ZodType<ListAgentsFallbacks, z.ZodTypeDef, unknown>;
-export declare function listAgentsFallbacksFromJSON(jsonString: string): SafeParseResult<ListAgentsFallbacks, SDKValidationError>;
+export declare const DataFallbacks$inboundSchema: z.ZodType<DataFallbacks, z.ZodTypeDef, unknown>;
+export declare function dataFallbacksFromJSON(jsonString: string): SafeParseResult<DataFallbacks, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsType$inboundSchema: z.ZodNativeEnum<typeof ListAgentsType>;
+export declare const ListAgentsDataAgentsResponseType$inboundSchema: z.ZodNativeEnum<typeof ListAgentsDataAgentsResponseType>;
 /** @internal */
-export declare const ListAgentsCache$inboundSchema: z.ZodType<ListAgentsCache, z.ZodTypeDef, unknown>;
-export declare function listAgentsCacheFromJSON(jsonString: string): SafeParseResult<ListAgentsCache, SDKValidationError>;
+export declare const DataCache$inboundSchema: z.ZodType<DataCache, z.ZodTypeDef, unknown>;
+export declare function dataCacheFromJSON(jsonString: string): SafeParseResult<DataCache, SDKValidationError>;
 /** @internal */
 export declare const ListAgentsLoadBalancerType$inboundSchema: z.ZodNativeEnum<typeof ListAgentsLoadBalancerType>;
 /** @internal */
@@ -1033,17 +1225,17 @@ export declare function listAgentsLoadBalancerModelsFromJSON(jsonString: string)
 export declare const ListAgentsLoadBalancer1$inboundSchema: z.ZodType<ListAgentsLoadBalancer1, z.ZodTypeDef, unknown>;
 export declare function listAgentsLoadBalancer1FromJSON(jsonString: string): SafeParseResult<ListAgentsLoadBalancer1, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsLoadBalancer$inboundSchema: z.ZodType<ListAgentsLoadBalancer, z.ZodTypeDef, unknown>;
-export declare function listAgentsLoadBalancerFromJSON(jsonString: string): SafeParseResult<ListAgentsLoadBalancer, SDKValidationError>;
+export declare const DataLoadBalancer$inboundSchema: z.ZodType<DataLoadBalancer, z.ZodTypeDef, unknown>;
+export declare function dataLoadBalancerFromJSON(jsonString: string): SafeParseResult<DataLoadBalancer, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsTimeout$inboundSchema: z.ZodType<ListAgentsTimeout, z.ZodTypeDef, unknown>;
-export declare function listAgentsTimeoutFromJSON(jsonString: string): SafeParseResult<ListAgentsTimeout, SDKValidationError>;
+export declare const DataTimeout$inboundSchema: z.ZodType<DataTimeout, z.ZodTypeDef, unknown>;
+export declare function dataTimeoutFromJSON(jsonString: string): SafeParseResult<DataTimeout, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsParameters$inboundSchema: z.ZodType<ListAgentsParameters, z.ZodTypeDef, unknown>;
-export declare function listAgentsParametersFromJSON(jsonString: string): SafeParseResult<ListAgentsParameters, SDKValidationError>;
+export declare const DataParameters$inboundSchema: z.ZodType<DataParameters, z.ZodTypeDef, unknown>;
+export declare function dataParametersFromJSON(jsonString: string): SafeParseResult<DataParameters, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsRetry$inboundSchema: z.ZodType<ListAgentsRetry, z.ZodTypeDef, unknown>;
-export declare function listAgentsRetryFromJSON(jsonString: string): SafeParseResult<ListAgentsRetry, SDKValidationError>;
+export declare const DataRetry$inboundSchema: z.ZodType<DataRetry, z.ZodTypeDef, unknown>;
+export declare function dataRetryFromJSON(jsonString: string): SafeParseResult<DataRetry, SDKValidationError>;
 /** @internal */
 export declare const ListAgentsResponseFormatAgentsResponseJsonSchema$inboundSchema: z.ZodType<ListAgentsResponseFormatAgentsResponseJsonSchema, z.ZodTypeDef, unknown>;
 export declare function listAgentsResponseFormatAgentsResponseJsonSchemaFromJSON(jsonString: string): SafeParseResult<ListAgentsResponseFormatAgentsResponseJsonSchema, SDKValidationError>;
@@ -1124,22 +1316,14 @@ export declare function listAgentsFallbackModelConfigurationRetryFromJSON(jsonSt
 export declare const ListAgentsFallbackModelConfiguration2$inboundSchema: z.ZodType<ListAgentsFallbackModelConfiguration2, z.ZodTypeDef, unknown>;
 export declare function listAgentsFallbackModelConfiguration2FromJSON(jsonString: string): SafeParseResult<ListAgentsFallbackModelConfiguration2, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsFallbackModelConfiguration$inboundSchema: z.ZodType<ListAgentsFallbackModelConfiguration, z.ZodTypeDef, unknown>;
-export declare function listAgentsFallbackModelConfigurationFromJSON(jsonString: string): SafeParseResult<ListAgentsFallbackModelConfiguration, SDKValidationError>;
-/** @internal */
-export declare const ListAgentsModel$inboundSchema: z.ZodType<ListAgentsModel, z.ZodTypeDef, unknown>;
-export declare function listAgentsModelFromJSON(jsonString: string): SafeParseResult<ListAgentsModel, SDKValidationError>;
-/** @internal */
-export declare const ListAgentsTeamOfAgents$inboundSchema: z.ZodType<ListAgentsTeamOfAgents, z.ZodTypeDef, unknown>;
-export declare function listAgentsTeamOfAgentsFromJSON(jsonString: string): SafeParseResult<ListAgentsTeamOfAgents, SDKValidationError>;
-/** @internal */
-export declare const ListAgentsMetrics$inboundSchema: z.ZodType<ListAgentsMetrics, z.ZodTypeDef, unknown>;
-export declare function listAgentsMetricsFromJSON(jsonString: string): SafeParseResult<ListAgentsMetrics, SDKValidationError>;
+export declare const DataFallbackModelConfiguration$inboundSchema: z.ZodType<DataFallbackModelConfiguration, z.ZodTypeDef, unknown>;
+export declare function dataFallbackModelConfigurationFromJSON(jsonString: string): SafeParseResult<DataFallbackModelConfiguration, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsKnowledgeBases$inboundSchema: z.ZodType<ListAgentsKnowledgeBases, z.ZodTypeDef, unknown>;
-export declare function listAgentsKnowledgeBasesFromJSON(jsonString: string): SafeParseResult<ListAgentsKnowledgeBases, SDKValidationError>;
+export declare const DataModel$inboundSchema: z.ZodType<DataModel, z.ZodTypeDef, unknown>;
+export declare function dataModelFromJSON(jsonString: string): SafeParseResult<DataModel, SDKValidationError>;
 /** @internal */
-export declare const ListAgentsSource$inboundSchema: z.ZodNativeEnum<typeof ListAgentsSource>;
+export declare const Data1$inboundSchema: z.ZodType<Data1, z.ZodTypeDef, unknown>;
+export declare function data1FromJSON(jsonString: string): SafeParseResult<Data1, SDKValidationError>;
 /** @internal */
 export declare const ListAgentsData$inboundSchema: z.ZodType<ListAgentsData, z.ZodTypeDef, unknown>;
 export declare function listAgentsDataFromJSON(jsonString: string): SafeParseResult<ListAgentsData, SDKValidationError>;