@droz-js/sdk 0.19.29 → 0.19.31

package/src/sdks/ai.d.ts

@@ -127,17 +127,530 @@ export type AgentInfo = {
     name: Scalars['String']['output'];
     picture?: Maybe<Scalars['String']['output']>;
 };
+export type AiAgentAuthoringRefInput = {
+    agentId: Scalars['ID']['input'];
+    id: Scalars['ID']['input'];
+};
+export type AiAgentBudget = {
+    /**
+     * Teto de gasto da conversa em micro-dolar (1e-6 USD). So vale para chamada com preco conhecido:
+     * modelo fora da tabela de preco produz custo desconhecido, nunca zero. Combine com `maxTokens`,
+     * que sempre vale.
+     */
+    maxCostMicroUsd?: Maybe<Scalars['Int']['output']>;
+    /**
+     * Teto de gasto do agente no periodo (mes calendario UTC), em micro-dolar. Ausente = sem teto de
+     * periodo. Independe de `maxCostMicroUsd`, que vale por conversa.
+     */
+    maxPeriodCostMicroUsd?: Maybe<Scalars['Int']['output']>;
+    maxSteps: Scalars['Int']['output'];
+    /** Teto de token da conversa inteira. Ausente = sem teto de token. */
+    maxTokens?: Maybe<Scalars['Int']['output']>;
+    maxToolCalls: Scalars['Int']['output'];
+    onExceeded: BudgetExceededAction;
+};
+export type AiAgentBudgetInput = {
+    maxCostMicroUsd?: InputMaybe<Scalars['Int']['input']>;
+    maxPeriodCostMicroUsd?: InputMaybe<Scalars['Int']['input']>;
+    maxSteps: Scalars['Int']['input'];
+    maxTokens?: InputMaybe<Scalars['Int']['input']>;
+    maxToolCalls: Scalars['Int']['input'];
+    onExceeded: BudgetExceededAction;
+};
+export type AiAgentCheckResult = {
+    regressions: Array<AiAgentRegression>;
+    reports: Array<AiAgentScenarioReport>;
+    /** Falso quando um cenário piorou além da tolerância em relação à versão live. */
+    safeToPublish: Scalars['Boolean']['output'];
+};
+export type AiAgentCompetingPair = {
+    left: Scalars['ID']['output'];
+    right: Scalars['ID']['output'];
+    /** Similaridade entre as duas descricoes, de 0 a 1. */
+    score: Scalars['Number']['output'];
+};
+export type AiAgentConversationMetrics = {
+    channel?: Maybe<Scalars['String']['output']>;
+    costMicroUsd: Scalars['Number']['output'];
+    durationMs: Scalars['Number']['output'];
+    lastOutcome: Scalars['String']['output'];
+    lastTurnAt: Scalars['Number']['output'];
+    sessionId: Scalars['ID']['output'];
+    startedAt: Scalars['Number']['output'];
+    totalTokens: Scalars['Number']['output'];
+    turns: Scalars['Number']['output'];
+};
+export type AiAgentConversationOutcome = {
+    agentId: Scalars['ID']['output'];
+    agentVersion: Scalars['String']['output'];
+    /** Fatos da sessao; chave e valor mascarados quando a politica de retencao pede. */
+    collectedData: Scalars['JSON']['output'];
+    /** false quando a retencao ja apagou a sessao. */
+    collectedDataAvailable: Scalars['Boolean']['output'];
+    /** Motivo da parada do ultimo turno, quando houve. */
+    haltReason?: Maybe<Scalars['String']['output']>;
+    lastTurnAt: Scalars['Number']['output'];
+    resolution: Scalars['String']['output'];
+    resolutionDefinition: Scalars['String']['output'];
+    sessionId: Scalars['ID']['output'];
+    startedAt: Scalars['Number']['output'];
+    turns: Scalars['Number']['output'];
+};
+/**
+ * Como este agente passa o atendimento para uma pessoa.
+ *
+ * A transicao vive no fluxo do tenant — e a state machine dele que sabe qual estado atende gente —,
+ * por isso e configuracao e nao constante da plataforma. Ausente significa que o agente nao passa
+ * para ninguem: ele diz que o caso precisa de uma pessoa e usa o comportamento fora de escopo do
+ * autor para dizer onde procura-la, em vez de prometer transferencia que nao acontece.
+ */
+export type AiAgentHandoff = {
+    /** `human` ou `flow`. Ausente = nao declarado: a metrica conta a parte, sem supor destino. */
+    target?: Maybe<Scalars['String']['output']>;
+    transition: Scalars['String']['output'];
+};
+export type AiAgentHandoffInput = {
+    target?: InputMaybe<Scalars['String']['input']>;
+    transition: Scalars['String']['input'];
+};
+export type AiAgentIdentity = {
+    displayName: Scalars['String']['output'];
+    openingMessage?: Maybe<Scalars['String']['output']>;
+    outOfScopeBehaviour: Scalars['String']['output'];
+    role: Scalars['String']['output'];
+    tone: TonePreset;
+    toneNotes?: Maybe<Scalars['String']['output']>;
+};
+export type AiAgentIdentityInput = {
+    displayName: Scalars['String']['input'];
+    openingMessage?: InputMaybe<Scalars['String']['input']>;
+    outOfScopeBehaviour: Scalars['String']['input'];
+    role: Scalars['String']['input'];
+    tone: TonePreset;
+    toneNotes?: InputMaybe<Scalars['String']['input']>;
+};
+export type AiAgentKnowledgeBase = {
+    id: Scalars['ID']['output'];
+    title: Scalars['String']['output'];
+};
+export type AiAgentMetrics = {
+    agentId: Scalars['ID']['output'];
+    answeredTurns: Scalars['Number']['output'];
+    /**
+     * Turnos que responderam mesmo com uma conexao falha no meio. E a superficie de risco do guardrail de
+     * §4.7 — nao prova resposta inventada, mas e onde ela poderia acontecer.
+     */
+    answeredWithFailedConnectionTurns: Scalars['Number']['output'];
+    avgLlmLatencyMs: Scalars['Number']['output'];
+    avgTurnDurationMs: Scalars['Number']['output'];
+    /** Turnos cuja resposta foi bloqueada na validacao antes do envio. */
+    blockedTurns: Scalars['Number']['output'];
+    blocksByCategory: Array<AiAgentMetricsCount>;
+    budgetExceededTurns: Scalars['Number']['output'];
+    /**
+     * Entrada servida pelo cache do proprio provedor: quanto do contexto nao foi pago a preco cheio.
+     * Provedor que nao reporta cache vale zero.
+     */
+    cachedInputTokens: Scalars['Number']['output'];
+    /** Turnos respondidos pelo cache, sem chamada ao modelo. E o ganho da otimizacao de §4.9. */
+    cachedTurns: Scalars['Number']['output'];
+    conversations: Scalars['Number']['output'];
+    /**
+     * Conversas em que algum turno **pediu** uma pessoa. Pedido, nao confirmacao: o disparo da transicao
+     * e best-effort, entao nem toda solicitacao virou transferencia de fato.
+     */
+    conversationsHandoffRequested: Scalars['Number']['output'];
+    /**
+     * Nem uma nem outra: parou por prazo, por repeticao, ou ainda esta acontecendo. Existe para nao
+     * inflar a resolucao — contar "nao transferiu" como "resolveu" transformaria conversa abandonada
+     * em sucesso.
+     */
+    conversationsInconclusive: Scalars['Number']['output'];
+    /** Conversas resolvidas sob a regra declarada em `resolutionDefinition`. */
+    conversationsResolved: Scalars['Number']['output'];
+    /** Gasto da janela em micro-dolar (1e-6 USD), inteiro. */
+    costMicroUsd: Scalars['Number']['output'];
+    /**
+     * Gasto da janela dividido pelas conversas resolvidas, em micro-dolar. **Ausente** quando nenhuma
+     * conversa resolveu no periodo — dividir por zero nao vira zero.
+     */
+    costMicroUsdPerResolvedConversation?: Maybe<Scalars['Number']['output']>;
+    /**
+     * Escalonou, mas a transicao nao tem destino declarado. Fica a parte de proposito: somar a um dos
+     * dois lados seria supor para onde o fluxo do tenant leva.
+     */
+    escalatedTargetUndeclared: Scalars['Number']['output'];
+    /** Escalonamentos cujo destino o autor declarou como fluxo. */
+    escalatedToFlow: Scalars['Number']['output'];
+    /** Escalonamentos cujo destino o autor declarou como pessoa. */
+    escalatedToHuman: Scalars['Number']['output'];
+    from: Scalars['Number']['output'];
+    haltReasons: Array<AiAgentMetricsCount>;
+    haltedTurns: Scalars['Number']['output'];
+    /**
+     * Por que a pessoa foi pedida: `customer_request` quando o consumidor pediu ou o agente concluiu que
+     * precisava, `tool_failure`, `provider_unavailable`, `budget_exceeded`, `period_budget_exceeded` ou
+     * `unresolved` quando o agente parou sem concluir.
+     */
+    handoffsByReason: Array<AiAgentMetricsCount>;
+    /** Turnos que terminaram pedindo uma pessoa (pedido, nao transferencia). */
+    humanRequestedTurns: Scalars['Number']['output'];
+    /** Turnos que precisaram de cliente identificado e nao tinham um — a medida do atrito de identificacao. */
+    identificationRequiredTurns: Scalars['Number']['output'];
+    inputTokens: Scalars['Number']['output'];
+    knowledgeEmpty: Scalars['Number']['output'];
+    knowledgeRetrieved: Scalars['Number']['output'];
+    knowledgeSkipped: Scalars['Number']['output'];
+    knowledgeUnavailable: Scalars['Number']['output'];
+    llmCalls: Scalars['Number']['output'];
+    outputTokens: Scalars['Number']['output'];
+    p95TurnDurationMs: Scalars['Number']['output'];
+    /** A regra aplicada para contar resolucao, junto do numero, para ele nao ser lido como cada um quiser. */
+    resolutionDefinition: Scalars['String']['output'];
+    /**
+     * Conversas resolvidas sobre o total, em pontos percentuais. **Ausente** quando nao houve conversa na
+     * janela — sem dado e zero por cento nao sao a mesma coisa.
+     */
+    resolutionRate?: Maybe<Scalars['Number']['output']>;
+    to: Scalars['Number']['output'];
+    toolCalls: Scalars['Number']['output'];
+    /** Chamadas de ferramenta que falharam. */
+    toolCallsFailed: Scalars['Number']['output'];
+    /** Falhas por classe: timeout, upstream, nao configurada, sem identificacao. */
+    toolErrorsByClass: Array<AiAgentMetricsCount>;
+    /** Falhas por conexao externa, identificada pelo host — responde "qual integracao esta caindo". */
+    toolErrorsByConnection: Array<AiAgentMetricsCount>;
+    /** Assuntos mais frequentes da janela, escolhidos no conjunto fechado do `can` de cada agente. */
+    topTopics: Array<AiAgentMetricsCount>;
+    /** As perguntas mais frequentes sem resposta, agrupadas por texto normalizado. */
+    topUnansweredQuestions: Array<AiAgentMetricsCount>;
+    totalTokens: Scalars['Number']['output'];
+    /** true quando o teto de leitura foi atingido: os numeros cobrem parte do periodo. */
+    truncated: Scalars['Boolean']['output'];
+    turns: Scalars['Number']['output'];
+    turnsByModel: Array<AiAgentMetricsCount>;
+    /**
+     * A regra aplicada para contar turno sem resposta, junto do numero, para ele nao ser lido como cada
+     * um quiser. Deterministica: qualidade da resposta nao e medivel aqui.
+     */
+    unansweredDefinition: Scalars['String']['output'];
+    /** Turnos sem resposta satisfatoria sob a regra declarada em `unansweredDefinition`. */
+    unansweredTurns: Scalars['Number']['output'];
+    /**
+     * Turnos com ao menos uma chamada ao modelo sem preco conhecido. Com isto > 0, `costMicroUsd` e
+     * **piso**, nao total — nao decidir preco sem olhar este numero.
+     */
+    unpricedTurns: Scalars['Number']['output'];
+};
+export type AiAgentMetricsCount = {
+    count: Scalars['Number']['output'];
+    key: Scalars['String']['output'];
+};
+export type AiAgentMetricsInput = {
+    agentId: Scalars['ID']['input'];
+    channel?: InputMaybe<Scalars['String']['input']>;
+    from: Scalars['Number']['input'];
+    to: Scalars['Number']['input'];
+};
+/** A mesma janela, sem agente: a listagem quer todos de uma vez. */
+export type AiAgentMetricsWindowInput = {
+    channel?: InputMaybe<Scalars['String']['input']>;
+    from: Scalars['Number']['input'];
+    to: Scalars['Number']['input'];
+};
+export type AiAgentProcedure = {
+    contingency: Scalars['String']['output'];
+    /** `autonomous` ou `needsApproval`. Ferramenta irreversivel exige `needsApproval`. */
+    executionAutonomy: Scalars['String']['output'];
+    /** As etapas como o autor instruiria uma pessoa. O texto e a fonte da verdade (§6.2). */
+    guidanceSteps: Array<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    status: Scalars['String']['output'];
+    /** Ferramentas que as etapas usam. Declaradas: e o que da para validar sem interpretar o texto. */
+    toolIds: Array<Scalars['ID']['output']>;
+    updatedAt: Scalars['Number']['output'];
+};
+export type AiAgentRefInput = {
+    agentId: Scalars['ID']['input'];
+};
+export type AiAgentRegression = {
+    after: Scalars['Float']['output'];
+    before: Scalars['Float']['output'];
+    scenarioId: Scalars['ID']['output'];
+};
+export type AiAgentRetentionDays = {
+    long_term_memory: Scalars['Int']['output'];
+    session_state: Scalars['Int']['output'];
+    transcript: Scalars['Int']['output'];
+};
+export type AiAgentRetentionDaysInput = {
+    long_term_memory: Scalars['Int']['input'];
+    session_state: Scalars['Int']['input'];
+    transcript: Scalars['Int']['input'];
+};
+export type AiAgentRetentionPolicy = {
+    days: AiAgentRetentionDays;
+    masksPersonalData: Scalars['Boolean']['output'];
+};
+export type AiAgentRetentionPolicyInput = {
+    days: AiAgentRetentionDaysInput;
+    masksPersonalData: Scalars['Boolean']['input'];
+};
+export type AiAgentRoutedExample = {
+    /** `high`, `medium` ou `low`. */
+    confidence: Scalars['String']['output'];
+    message: Scalars['String']['output'];
+    score: Scalars['Number']['output'];
+    /** Ausente quando nenhum caso de uso reconheceu a mensagem. */
+    useCaseId?: Maybe<Scalars['ID']['output']>;
+};
+export type AiAgentRoutingPreview = {
+    examples: Array<AiAgentRoutedExample>;
+    /** Limiar de confianca alta. */
+    high: Scalars['Number']['output'];
+    /** Limiar de confianca media; abaixo dele a previa nao aponta caso de uso. */
+    medium: Scalars['Number']['output'];
+};
+export type AiAgentRoutingPreviewInput = {
+    agentId: Scalars['ID']['input'];
+    /** Mensagens a testar. Vazio cai em `subject`; sem os dois, previa vazia e nao erro. */
+    examples: Array<Scalars['String']['input']>;
+    /** Descricao do assunto: as mensagens sao geradas a partir dela (§5.4). Ignorada se `examples` vier. */
+    subject?: InputMaybe<Scalars['String']['input']>;
+};
+export type AiAgentScenario = {
+    description: Scalars['String']['output'];
+    expectations: Array<Scalars['JSON']['output']>;
+    scenarioId: Scalars['ID']['output'];
+    /** O que o cliente diz, em ordem. */
+    turns: Array<Scalars['String']['output']>;
+};
+export type AiAgentScenarioReport = {
+    passed: Scalars['Int']['output'];
+    /** Fração de execuções em que todas as expectativas valeram, 0..1. */
+    rate: Scalars['Float']['output'];
+    runs: Scalars['Int']['output'];
+    scenarioId: Scalars['ID']['output'];
+    /** Um item por turno do cenário, na ordem, agregado entre as execuções. */
+    turns: Array<AiAgentScenarioTurn>;
+};
+export type AiAgentScenarioTurn = {
+    /** Execuções em que o agente respondeu neste turno. */
+    answered: Scalars['Int']['output'];
+    /** Categorias que bloquearam a resposta deste turno, e em quantas execuções. */
+    blockCategories: Array<AiAgentMetricsCount>;
+    /** Execuções em que a resposta deste turno foi bloqueada antes do envio. */
+    blocked: Scalars['Int']['output'];
+    /** Execuções em que a resposta deste turno se apoiou em conhecimento ou ferramenta. */
+    grounded: Scalars['Int']['output'];
+    /** Execuções que chegaram a este turno. */
+    runs: Scalars['Int']['output'];
+    /** Ferramentas chamadas neste turno, e em quantas execuções. */
+    toolNames: Array<AiAgentMetricsCount>;
+    /** 1 para o primeiro turno do cenário. */
+    turn: Scalars['Int']['output'];
+};
+export type AiAgentSpec = {
+    budget: AiAgentBudget;
+    /** One natural-language permission per item. */
+    can: Array<Scalars['String']['output']>;
+    /** Restrictions. On conflict these win over `can`, without exception. */
+    cannot: Array<Scalars['String']['output']>;
+    /** Canais em que o agente atende. Ausente = ainda nao vinculado; declarado vazio e erro. */
+    channels?: Maybe<Array<Scalars['String']['output']>>;
+    handoff?: Maybe<AiAgentHandoff>;
+    identity: AiAgentIdentity;
+    /**
+     * §4.8: bases do Droz Base vinculadas — ids de **space**, nao de credencial. A consulta e recortada
+     * por elas; sem recorte o agente varreria o acervo inteiro do tenant.
+     */
+    knowledgeBaseIds: Array<Scalars['ID']['output']>;
+    /** `inform_limitation` (default) ou `general_knowledge`; ausente vale o mais restritivo. */
+    knowledgeFallback?: Maybe<Scalars['String']['output']>;
+    toolIds: Array<Scalars['ID']['output']>;
+};
+export type AiAgentSpecInput = {
+    budget: AiAgentBudgetInput;
+    can: Array<Scalars['String']['input']>;
+    cannot: Array<Scalars['String']['input']>;
+    channels?: InputMaybe<Array<Scalars['String']['input']>>;
+    handoff?: InputMaybe<AiAgentHandoffInput>;
+    identity: AiAgentIdentityInput;
+    /**
+     * §4.8: bases do Droz Base vinculadas — ids de **space**, nao de credencial. A consulta e recortada
+     * por elas; sem recorte o agente varreria o acervo inteiro do tenant.
+     */
+    knowledgeBaseIds: Array<Scalars['ID']['input']>;
+    /** `inform_limitation` (default) ou `general_knowledge`; ausente vale o mais restritivo. */
+    knowledgeFallback?: InputMaybe<Scalars['String']['input']>;
+    toolIds: Array<Scalars['ID']['input']>;
+};
+export type AiAgentSummary = {
+    agentId: Scalars['ID']['output'];
+    /** Canais da versao no ar; sem versao no ar, os da mais recente. Vazio quando nenhuma declarou canal. */
+    channels: Array<Scalars['String']['output']>;
+    /** Absent until a version is published. An agent with no live version answers nobody. */
+    liveVersion?: Maybe<Scalars['Int']['output']>;
+    name: Scalars['String']['output'];
+    /** Acoes esperando aprovacao humana (§5.5.3). Zero tambem quando a fila nao pode ser lida. */
+    queuedApprovals: Scalars['Number']['output'];
+    /**
+     * `draft` (nunca publicado), `live` (no ar) ou `paused` (ja esteve no ar e foi tirado). `liveVersion`
+     * sozinho nao distingue quem nunca publicou de quem foi pausado.
+     */
+    status: Scalars['String']['output'];
+    /** Momento da versao mais recente, no ar ou nao — o "ultima alteracao" da listagem. */
+    updatedAt: Scalars['Number']['output'];
+};
+export type AiAgentTool = {
+    /** `pre_approved` (padrao) ou `human_approval`. */
+    approval?: Maybe<Scalars['String']['output']>;
+    availability: ToolAvailability;
+    /** `url` (default): a plataforma impoe o recorte via `{customerId}` na URL; `credential`: a credencial ja e do cliente (declarado, nunca inferido). */
+    customerScope?: Maybe<Scalars['String']['output']>;
+    description: Scalars['String']['output'];
+    effect: ToolEffect;
+    name: Scalars['String']['output'];
+    /** `{kind: message, message?}` (default), `{kind: retry, attempts, message?}` ou `{kind: handoff}`. */
+    onFailure?: Maybe<Scalars['JSON']['output']>;
+    parameters: Array<AiAgentToolParameter>;
+    requiresAuthenticatedCustomer: Scalars['Boolean']['output'];
+    /** Fields the agent is allowed to see. Anything not listed never reaches the model. */
+    returns: Array<Scalars['String']['output']>;
+    toolId: Scalars['ID']['output'];
+};
+export type AiAgentToolParameter = {
+    description: Scalars['String']['output'];
+    grounding: ParameterGrounding;
+    name: Scalars['String']['output'];
+    required: Scalars['Boolean']['output'];
+    type: ToolParameterType;
+};
+export type AiAgentToolParameterInput = {
+    description: Scalars['String']['input'];
+    groundedBy?: InputMaybe<Array<Scalars['String']['input']>>;
+    grounding?: InputMaybe<ParameterGrounding>;
+    name: Scalars['String']['input'];
+    required: Scalars['Boolean']['input'];
+    type: ToolParameterType;
+};
+export type AiAgentToolSpecInput = {
+    /** `pre_approved` (padrao) ou `human_approval`. */
+    approval?: InputMaybe<Scalars['String']['input']>;
+    availability: ToolAvailability;
+    credentialRef?: InputMaybe<CredentialRefInput>;
+    /** `url` (default): a plataforma impoe o recorte via `{customerId}` na URL; `credential`: a credencial ja e do cliente (declarado, nunca inferido). */
+    customerScope?: InputMaybe<Scalars['String']['input']>;
+    description: Scalars['String']['input'];
+    effect: ToolEffect;
+    idempotent: Scalars['Boolean']['input'];
+    name: Scalars['String']['input'];
+    /** `{kind: message, message?}` (default), `{kind: retry, attempts, message?}` ou `{kind: handoff}`. */
+    onFailure?: InputMaybe<Scalars['JSON']['input']>;
+    parameters: Array<AiAgentToolParameterInput>;
+    requiresAuthenticatedCustomer: Scalars['Boolean']['input'];
+    /** Campos que o agente pode ver. O que não estiver aqui nunca chega ao modelo. */
+    returns: Array<Scalars['String']['input']>;
+    reversible: Scalars['Boolean']['input'];
+    toolId: Scalars['ID']['input'];
+};
+export type AiAgentTrace = {
+    agentId: Scalars['ID']['output'];
+    agentVersion: Scalars['String']['output'];
+    answer: Scalars['String']['output'];
+    /** Presente so quando o turno parou por limite; ausente quando respondeu. */
+    haltReason?: Maybe<Scalars['String']['output']>;
+    /** O turno tentou usar ferramenta que exige cliente identificado, sem ter um. */
+    identificationRequired?: Maybe<Scalars['Boolean']['output']>;
+    input: Scalars['String']['output'];
+    knowledgeOrigins: Array<Scalars['String']['output']>;
+    /** Versao da regra mestra da plataforma vigente no turno — atribui a conversa a regra sob a qual ela rodou. */
+    masterRuleVersion?: Maybe<Scalars['Int']['output']>;
+    outcome: Scalars['String']['output'];
+    promptBuilderVersion: Scalars['Int']['output'];
+    /** Identifica o prompt que gerou este turno sem guardar o prompt inteiro. */
+    promptFingerprint: Scalars['String']['output'];
+    sessionId: Scalars['ID']['output'];
+    startedAt: Scalars['Float']['output'];
+    steps: Scalars['Int']['output'];
+    toolCalls: Array<AiAgentTracedToolCall>;
+    turn: Scalars['Int']['output'];
+};
+export type AiAgentTracedToolCall = {
+    /** O sistema externo, pelo host. Sem path nem query, que carregam parametro do cliente. */
+    connection?: Maybe<Scalars['String']['output']>;
+    /** `unauthenticated`, `not_configured`, `timeout` ou `upstream`. */
+    errorClass?: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    /**
+     * Se a chamada deu certo. Ausente em chamada gravada antes do desfecho estruturado existir — e
+     * ausente nao significa falha.
+     */
+    ok?: Maybe<Scalars['Boolean']['output']>;
+    /** Ja restrito aos campos que a ferramenta declarou em `returns`. */
+    result: Scalars['String']['output'];
+    toolId: Scalars['ID']['output'];
+};
+export type AiAgentUseCase = {
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    procedureId?: Maybe<Scalars['ID']['output']>;
+    status: Scalars['String']['output'];
+    /**
+     * NAO e documentacao: e o texto que o roteador le para classificar a mensagem (§6.1). Descricao vaga
+     * produz roteamento ruim.
+     */
+    subjectDescription: Scalars['String']['output'];
+    updatedAt: Scalars['Number']['output'];
+};
+export type AiAgentUseCaseOverlap = {
+    /** Do par mais parecido para o menos: e a ordem em que o autor deve olhar. */
+    pairs: Array<AiAgentCompetingPair>;
+    /** O limiar aplicado, publicado junto do resultado para o aviso nao ser lido como cada um quiser. */
+    threshold: Scalars['Number']['output'];
+};
+export type AiAgentVersion = {
+    agentId: Scalars['ID']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    spec: AiAgentSpec;
+    status: AiAgentVersionStatus;
+    version: Scalars['Int']['output'];
+};
+export type AiAgentVersionRefInput = {
+    agentId: Scalars['ID']['input'];
+    version: Scalars['Int']['input'];
+};
+export declare enum AiAgentVersionStatus {
+    Draft = "draft",
+    Live = "live",
+    Published = "published",
+    Removed = "removed"
+}
 export declare enum AppInstanceStatus {
     Active = "Active",
     Failing = "Failing",
     Inactive = "Inactive"
 }
+export declare enum BudgetExceededAction {
+    DegradeModel = "degrade_model",
+    EndWithNotice = "end_with_notice",
+    TransferToHuman = "transfer_to_human"
+}
 export declare enum Can {
     Manage = "manage",
     Read = "read",
     Remove = "remove",
     Write = "write"
 }
+export type CheckAiAgentVersionInput = {
+    agentId: Scalars['ID']['input'];
+    /** De 2 a 20. Uma execução só não prova nada num sistema probabilístico. */
+    runsPerScenario?: InputMaybe<Scalars['Int']['input']>;
+    /** Cenários a rodar. Ausente roda todos; o resultado cobre só os cenários rodados. */
+    scenarioIds?: InputMaybe<Array<Scalars['ID']['input']>>;
+    version: Scalars['Int']['input'];
+};
 export type CreateNlpInstanceInput = {
     name: Scalars['String']['input'];
     options: Array<NlpOptionInput>;
@@ -147,6 +660,17 @@ export type CreateQnAInstanceInput = {
     name: Scalars['String']['input'];
     tryToReplyOnTransition?: InputMaybe<Scalars['Boolean']['input']>;
 };
+export type CredentialRefInput = {
+    /** Nome do parâmetro no cofre do tenant. O valor nunca é armazenado aqui. */
+    name: Scalars['String']['input'];
+    vault: Scalars['String']['input'];
+};
+export type DraftAiAgentInput = {
+    /** Omitted for a brand new agent; supplied to draft the next version of an existing one. */
+    agentId?: InputMaybe<Scalars['ID']['input']>;
+    name: Scalars['String']['input'];
+    spec: AiAgentSpecInput;
+};
 export type ExtractImageMetadataInput = {
     imageUrl: Scalars['String']['input'];
     metadataRequirements: Scalars['JSONObject']['input'];
@@ -166,30 +690,98 @@ export type I18nTextInput = {
     value: Scalars['String']['input'];
 };
 export type Mutation = {
+    /** Roda os cenários contra uma versão candidata e registra o resultado. Custa chamadas de modelo. */
+    checkAiAgentVersion?: Maybe<AiAgentCheckResult>;
     createNlpInstance?: Maybe<NlpInstance>;
     createQnAInstance?: Maybe<QnAInstance>;
+    draftAiAgent?: Maybe<AiAgentVersion>;
     extractImageMetadata: ExtractImageMetadataResult;
+    publishAiAgentVersion: Array<AiAgentVersion>;
+    registerAiAgentTool?: Maybe<AiAgentTool>;
+    /** Apaga o agente e a autoria dele. Agente no ar precisa ser pausado antes. */
+    removeAiAgent: Scalars['Boolean']['output'];
+    removeAiAgentProcedure: Scalars['Boolean']['output'];
+    removeAiAgentUseCase: Scalars['Boolean']['output'];
+    removeAiAgentVersion: Array<AiAgentVersion>;
     removeNlpInstance?: Maybe<NlpInstance>;
     removeQnAInstance?: Maybe<QnAInstance>;
+    /** Decide uma acao que ficou esperando aprovacao humana (§5.5.3). Decidir de novo nao repete a acao. */
+    resolveAiAgentApproval: Scalars['Boolean']['output'];
+    rollbackAiAgentVersion: Array<AiAgentVersion>;
+    saveAiAgentProcedure: AiAgentProcedure;
+    saveAiAgentScenario?: Maybe<AiAgentScenario>;
+    saveAiAgentUseCase: AiAgentUseCase;
+    setAiAgentRetentionPolicy: AiAgentRetentionPolicy;
+    /** Tira a versao do ar sem apagar (pausar). Publicar de novo e o caminho de volta. */
+    unpublishAiAgentVersion: Array<AiAgentVersion>;
+    unregisterAiAgentTool?: Maybe<Scalars['Boolean']['output']>;
     updateNlpInstance?: Maybe<NlpInstance>;
     updateQnAInstance?: Maybe<QnAInstance>;
     version?: Maybe<Scalars['String']['output']>;
 };
+export type MutationCheckAiAgentVersionArgs = {
+    input: CheckAiAgentVersionInput;
+};
 export type MutationCreateNlpInstanceArgs = {
     input: CreateNlpInstanceInput;
 };
 export type MutationCreateQnAInstanceArgs = {
     input: CreateQnAInstanceInput;
 };
+export type MutationDraftAiAgentArgs = {
+    input: DraftAiAgentInput;
+};
 export type MutationExtractImageMetadataArgs = {
     input: ExtractImageMetadataInput;
 };
+export type MutationPublishAiAgentVersionArgs = {
+    input: AiAgentVersionRefInput;
+};
+export type MutationRegisterAiAgentToolArgs = {
+    input: RegisterAiAgentToolInput;
+};
+export type MutationRemoveAiAgentArgs = {
+    input: AiAgentRefInput;
+};
+export type MutationRemoveAiAgentProcedureArgs = {
+    input: AiAgentAuthoringRefInput;
+};
+export type MutationRemoveAiAgentUseCaseArgs = {
+    input: AiAgentAuthoringRefInput;
+};
+export type MutationRemoveAiAgentVersionArgs = {
+    input: AiAgentVersionRefInput;
+};
 export type MutationRemoveNlpInstanceArgs = {
     input: RemoveNlpInstanceInput;
 };
 export type MutationRemoveQnAInstanceArgs = {
     input: RemoveQnAInstanceInput;
 };
+export type MutationResolveAiAgentApprovalArgs = {
+    input: ResolveAiAgentApprovalInput;
+};
+export type MutationRollbackAiAgentVersionArgs = {
+    input: AiAgentVersionRefInput;
+};
+export type MutationSaveAiAgentProcedureArgs = {
+    input: SaveAiAgentProcedureInput;
+};
+export type MutationSaveAiAgentScenarioArgs = {
+    input: SaveAiAgentScenarioInput;
+};
+export type MutationSaveAiAgentUseCaseArgs = {
+    input: SaveAiAgentUseCaseInput;
+};
+export type MutationSetAiAgentRetentionPolicyArgs = {
+    input: AiAgentRetentionPolicyInput;
+};
+export type MutationUnpublishAiAgentVersionArgs = {
+    input: AiAgentVersionRefInput;
+};
+export type MutationUnregisterAiAgentToolArgs = {
+    input: UnregisterAiAgentToolInput;
+};
 export type MutationUpdateNlpInstanceArgs = {
     input: UpdateNlpInstanceInput;
 };
@@ -234,6 +826,10 @@ export type PageInfo = {
     hasNext: Scalars['Boolean']['output'];
     next?: Maybe<Scalars['Base64']['output']>;
 };
+export declare enum ParameterGrounding {
+    Free = "free",
+    Required = "required"
+}
 export type QnAInstance = {
     createdAt: Scalars['DateTime']['output'];
     credentialsId: Scalars['ID']['output'];
@@ -244,22 +840,90 @@ export type QnAInstance = {
     updatedAt: Scalars['DateTime']['output'];
 };
 export type Query = {
+    aiAgentConversationMetrics: Array<AiAgentConversationMetrics>;
+    aiAgentConversationOutcome?: Maybe<AiAgentConversationOutcome>;
+    /**
+     * §4.8: as bases do Droz Base do tenant. A chamada e entre services, com App Token — nao ha
+     * credencial de cliente. O recorte do agente e a selecao do autor em `knowledgeBaseIds`.
+     */
+    aiAgentKnowledgeBases: Array<AiAgentKnowledgeBase>;
+    aiAgentMetrics: AiAgentMetrics;
+    /** As metricas da janela para todos os agentes, numa ida so. Agente sem rastro vem com zeros. */
+    aiAgentMetricsByAgent: Array<AiAgentMetrics>;
+    /**
+     * A politica de retencao em vigor para o tenant, com os padroes aplicados quando ele nao
+     * configurou a propria. Existe para a politica ser verificavel de fora, nao so estar escrita.
+     */
+    aiAgentRetentionPolicy: AiAgentRetentionPolicy;
+    /** Onde cada mensagem de exemplo cairia (§5.4). Os limiares saem no resultado: `medium` sem o limiar nao diz nada. */
+    aiAgentRoutingPreview: AiAgentRoutingPreview;
+    /**
+     * Os turnos de um atendimento, do primeiro ao ultimo. E o que responde "o que aconteceu nesta
+     * conversa" sem depender de ler o DynamoDB por fora.
+     */
+    aiAgentTrace: Array<AiAgentTrace>;
+    /**
+     * Casos de uso cujas descricoes competem no roteador (§6.1). Aviso de autoria, nao bloqueio: descricoes
+     * parecidas podem ser intencionais.
+     */
+    aiAgentUseCaseOverlap: AiAgentUseCaseOverlap;
     app?: Maybe<Scalars['DRN']['output']>;
     getHttpEndpoint?: Maybe<Scalars['String']['output']>;
     getNlpInstance?: Maybe<NlpInstance>;
     getQnAInstance?: Maybe<QnAInstance>;
+    /** Os procedimentos do agente (§6.2): o plano em linguagem natural. */
+    listAiAgentProcedures: Array<AiAgentProcedure>;
+    listAiAgentScenarios: Array<AiAgentScenario>;
+    listAiAgentTools: Array<AiAgentTool>;
+    /** Os casos de uso do agente (§6.1): os motivos de contato. */
+    listAiAgentUseCases: Array<AiAgentUseCase>;
+    listAiAgentVersions: Array<AiAgentVersion>;
+    listAiAgents: Array<AiAgentSummary>;
     listNlpInstances: Array<NlpInstance>;
     listQnAInstances: Array<QnAInstance>;
     testNlpInstance?: Maybe<TestNlpInstanceResult>;
     testQnAInstance?: Maybe<TestQnAInstanceResult>;
     version?: Maybe<Scalars['String']['output']>;
 };
+export type QueryAiAgentConversationMetricsArgs = {
+    input: AiAgentMetricsInput;
+};
+export type QueryAiAgentConversationOutcomeArgs = {
+    sessionId: Scalars['ID']['input'];
+};
+export type QueryAiAgentMetricsArgs = {
+    input: AiAgentMetricsInput;
+};
+export type QueryAiAgentMetricsByAgentArgs = {
+    input: AiAgentMetricsWindowInput;
+};
+export type QueryAiAgentRoutingPreviewArgs = {
+    input: AiAgentRoutingPreviewInput;
+};
+export type QueryAiAgentTraceArgs = {
+    sessionId: Scalars['ID']['input'];
+};
+export type QueryAiAgentUseCaseOverlapArgs = {
+    agentId: Scalars['ID']['input'];
+};
 export type QueryGetNlpInstanceArgs = {
     id: Scalars['ID']['input'];
 };
 export type QueryGetQnAInstanceArgs = {
     id: Scalars['ID']['input'];
 };
+export type QueryListAiAgentProceduresArgs = {
+    agentId: Scalars['ID']['input'];
+};
+export type QueryListAiAgentScenariosArgs = {
+    agentId: Scalars['ID']['input'];
+};
+export type QueryListAiAgentUseCasesArgs = {
+    agentId: Scalars['ID']['input'];
+};
+export type QueryListAiAgentVersionsArgs = {
+    agentId: Scalars['ID']['input'];
+};
 export type QueryTestNlpInstanceArgs = {
     id: Scalars['ID']['input'];
     sample: Scalars['String']['input'];
@@ -269,12 +933,59 @@ export type QueryTestQnAInstanceArgs = {
     id: Scalars['ID']['input'];
     input: Scalars['String']['input'];
 };
+export type RegisterAiAgentToolInput = {
+    method: Scalars['String']['input'];
+    spec: AiAgentToolSpecInput;
+    /** Pode conter {param} para parâmetros declarados e {customerId}. Precisa ser https e público. */
+    url: Scalars['String']['input'];
+};
 export type RemoveNlpInstanceInput = {
     id: Scalars['ID']['input'];
 };
 export type RemoveQnAInstanceInput = {
     id: Scalars['ID']['input'];
 };
+export type ResolveAiAgentApprovalInput = {
+    agentId: Scalars['ID']['input'];
+    decidedBy: Scalars['String']['input'];
+    /** `approved` executa a acao guardada; `rejected` avisa o consumidor e nao executa nada. */
+    decision: Scalars['String']['input'];
+    /** Identifica a pendencia junto da sessao: e o momento em que a acao foi enfileirada. */
+    requestedAt: Scalars['Number']['input'];
+    sessionId: Scalars['ID']['input'];
+};
+export type SaveAiAgentProcedureInput = {
+    agentId: Scalars['ID']['input'];
+    contingency: Scalars['String']['input'];
+    executionAutonomy: Scalars['String']['input'];
+    guidanceSteps: Array<Scalars['String']['input']>;
+    id: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+    status: Scalars['String']['input'];
+    toolIds: Array<Scalars['ID']['input']>;
+};
+export type SaveAiAgentScenarioInput = {
+    agentId: Scalars['ID']['input'];
+    description: Scalars['String']['input'];
+    /**
+     * Expectativas de comportamento, uma por objeto, cada uma com `kind`. `tool_called` aceita
+     * `toolName` e `withArgs`; `tool_not_called` aceita `toolName`; `blocked_by_rule` aceita `category`
+     * para exigir o motivo; `stopped_for` aceita `reason`; `answer_omits` exige `terms`, e vale quando
+     * nenhum termo aparece em nenhuma resposta da execucao, sem acento e sem caixa. `transferred`,
+     * `not_transferred` e `answer_grounded` nao levam campo.
+     */
+    expectations: Array<Scalars['JSON']['input']>;
+    scenarioId: Scalars['ID']['input'];
+    turns: Array<Scalars['String']['input']>;
+};
+export type SaveAiAgentUseCaseInput = {
+    agentId: Scalars['ID']['input'];
+    id: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+    procedureId?: InputMaybe<Scalars['ID']['input']>;
+    status: Scalars['String']['input'];
+    subjectDescription: Scalars['String']['input'];
+};
 export type SearchResultsFacet = {
     name: Scalars['String']['output'];
     stats?: Maybe<SearchResultsFacetStats>;
@@ -342,7 +1053,39 @@ export type TokenUsage = {
     prompt?: Maybe<Scalars['Int']['output']>;
     total?: Maybe<Scalars['Int']['output']>;
 };
+export declare enum TonePreset {
+    Cordial = "cordial",
+    Descontraido = "descontraido",
+    Direto = "direto",
+    Formal = "formal",
+    Tecnico = "tecnico"
+}
+export declare enum ToolAvailability {
+    Available = "available",
+    Unavailable = "unavailable"
+}
+export declare enum ToolEffect {
+    Read = "read",
+    Write = "write"
+}
+export declare enum ToolParameterType {
+    Boolean = "boolean",
+    Number = "number",
+    String = "string"
+}
 export declare enum Typenames {
+    AiAgentAnswerCache = "AiAgentAnswerCache",
+    AiAgentApproval = "AiAgentApproval",
+    AiAgentEvalReport = "AiAgentEvalReport",
+    AiAgentProcedure = "AiAgentProcedure",
+    AiAgentRetentionPolicy = "AiAgentRetentionPolicy",
+    AiAgentScenario = "AiAgentScenario",
+    AiAgentSession = "AiAgentSession",
+    AiAgentSpend = "AiAgentSpend",
+    AiAgentTool = "AiAgentTool",
+    AiAgentTrace = "AiAgentTrace",
+    AiAgentUseCase = "AiAgentUseCase",
+    AiAgentVersion = "AiAgentVersion",
     Any = "Any",
     GraphqlConnections = "GraphqlConnections",
     GraphqlSubscriptions = "GraphqlSubscriptions",
@@ -350,6 +1093,9 @@ export declare enum Typenames {
     NlpEmbeddings = "NlpEmbeddings",
     QnA = "QnA"
 }
+export type UnregisterAiAgentToolInput = {
+    toolId: Scalars['ID']['input'];
+};
 export type UpdateNlpInstanceInput = {
     id: Scalars['ID']['input'];
     name?: InputMaybe<Scalars['String']['input']>;
@@ -361,6 +1107,229 @@ export type UpdateQnAInstanceInput = {
     name?: InputMaybe<Scalars['String']['input']>;
     tryToReplyOnTransition?: InputMaybe<Scalars['Boolean']['input']>;
 };
+export type AiAgentSummaryFragment = Pick<AiAgentSummary, 'agentId' | 'name' | 'liveVersion' | 'channels' | 'updatedAt' | 'queuedApprovals' | 'status'>;
+export type AiAgentVersionFragment = Pick<AiAgentVersion, 'agentId' | 'version' | 'status' | 'createdAt'>;
+export type AiAgentSpecFragment = (Pick<AiAgentSpec, 'can' | 'cannot' | 'knowledgeBaseIds' | 'knowledgeFallback' | 'toolIds' | 'channels'> & {
+    identity: Pick<AiAgentIdentity, 'displayName' | 'role' | 'tone' | 'toneNotes' | 'openingMessage' | 'outOfScopeBehaviour'>;
+    budget: Pick<AiAgentBudget, 'maxSteps' | 'maxToolCalls' | 'maxTokens' | 'maxCostMicroUsd' | 'maxPeriodCostMicroUsd' | 'onExceeded'>;
+    handoff?: Maybe<Pick<AiAgentHandoff, 'transition' | 'target'>>;
+});
+export type AiAgentVersionWithSpecFragment = (Pick<AiAgentVersion, 'agentId' | 'version' | 'status' | 'createdAt'> & {
+    spec: AiAgentSpecFragment;
+});
+export type AiAgentListingMetricsFragment = Pick<AiAgentMetrics, 'agentId' | 'conversations' | 'conversationsResolved' | 'conversationsHandoffRequested' | 'resolutionRate' | 'resolutionDefinition' | 'costMicroUsd'>;
+export type ListAiAgentsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type ListAiAgentsQuery = {
+    listAiAgents: Array<AiAgentSummaryFragment>;
+};
+export type ListAiAgentVersionsQueryVariables = Exact<{
+    agentId: Scalars['ID']['input'];
+}>;
+export type ListAiAgentVersionsQuery = {
+    listAiAgentVersions: Array<AiAgentVersionFragment>;
+};
+export type AiAgentMetricsByAgentQueryVariables = Exact<{
+    input: AiAgentMetricsWindowInput;
+}>;
+export type AiAgentMetricsByAgentQuery = {
+    aiAgentMetricsByAgent: Array<AiAgentListingMetricsFragment>;
+};
+export type DraftAiAgentMutationVariables = Exact<{
+    input: DraftAiAgentInput;
+}>;
+export type DraftAiAgentMutation = {
+    draftAiAgent?: Maybe<AiAgentVersionFragment>;
+};
+export type PublishAiAgentVersionMutationVariables = Exact<{
+    input: AiAgentVersionRefInput;
+}>;
+export type PublishAiAgentVersionMutation = {
+    publishAiAgentVersion: Array<AiAgentVersionFragment>;
+};
+export type UnpublishAiAgentVersionMutationVariables = Exact<{
+    input: AiAgentVersionRefInput;
+}>;
+export type UnpublishAiAgentVersionMutation = {
+    unpublishAiAgentVersion: Array<AiAgentVersionFragment>;
+};
+export type RollbackAiAgentVersionMutationVariables = Exact<{
+    input: AiAgentVersionRefInput;
+}>;
+export type RollbackAiAgentVersionMutation = {
+    rollbackAiAgentVersion: Array<AiAgentVersionFragment>;
+};
+export type RemoveAiAgentVersionMutationVariables = Exact<{
+    input: AiAgentVersionRefInput;
+}>;
+export type RemoveAiAgentVersionMutation = {
+    removeAiAgentVersion: Array<AiAgentVersionFragment>;
+};
+export type RemoveAiAgentMutationVariables = Exact<{
+    input: AiAgentRefInput;
+}>;
+export type RemoveAiAgentMutation = Pick<Mutation, 'removeAiAgent'>;
+export type AiAgentUseCaseFragment = Pick<AiAgentUseCase, 'id' | 'name' | 'subjectDescription' | 'procedureId' | 'status' | 'updatedAt'>;
+export type AiAgentProcedureFragment = Pick<AiAgentProcedure, 'id' | 'name' | 'guidanceSteps' | 'toolIds' | 'contingency' | 'executionAutonomy' | 'status' | 'updatedAt'>;
+export type AiAgentToolFragment = (Pick<AiAgentTool, 'toolId' | 'name' | 'description' | 'effect' | 'availability' | 'requiresAuthenticatedCustomer' | 'onFailure' | 'customerScope' | 'returns' | 'approval'> & {
+    parameters: Array<Pick<AiAgentToolParameter, 'name' | 'type' | 'required' | 'description' | 'grounding'>>;
+});
+export type AiAgentTraceFragment = (Pick<AiAgentTrace, 'sessionId' | 'turn' | 'agentId' | 'agentVersion' | 'input' | 'promptBuilderVersion' | 'masterRuleVersion' | 'identificationRequired' | 'promptFingerprint' | 'knowledgeOrigins' | 'outcome' | 'haltReason' | 'steps' | 'answer' | 'startedAt'> & {
+    toolCalls: Array<Pick<AiAgentTracedToolCall, 'toolId' | 'name' | 'result' | 'ok' | 'connection' | 'errorClass'>>;
+});
+export type AiAgentScenarioFragment = Pick<AiAgentScenario, 'scenarioId' | 'description' | 'turns' | 'expectations'>;
+export type ListAiAgentUseCasesQueryVariables = Exact<{
+    agentId: Scalars['ID']['input'];
+}>;
+export type ListAiAgentUseCasesQuery = {
+    listAiAgentUseCases: Array<AiAgentUseCaseFragment>;
+};
+export type ListAiAgentProceduresQueryVariables = Exact<{
+    agentId: Scalars['ID']['input'];
+}>;
+export type ListAiAgentProceduresQuery = {
+    listAiAgentProcedures: Array<AiAgentProcedureFragment>;
+};
+export type ListAiAgentToolsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type ListAiAgentToolsQuery = {
+    listAiAgentTools: Array<AiAgentToolFragment>;
+};
+export type AiAgentUseCaseOverlapQueryVariables = Exact<{
+    agentId: Scalars['ID']['input'];
+}>;
+export type AiAgentUseCaseOverlapQuery = {
+    aiAgentUseCaseOverlap: (Pick<AiAgentUseCaseOverlap, 'threshold'> & {
+        pairs: Array<Pick<AiAgentCompetingPair, 'left' | 'right' | 'score'>>;
+    });
+};
+export type AiAgentTraceQueryVariables = Exact<{
+    sessionId: Scalars['ID']['input'];
+}>;
+export type AiAgentTraceQuery = {
+    aiAgentTrace: Array<AiAgentTraceFragment>;
+};
+export type ListAiAgentScenariosQueryVariables = Exact<{
+    agentId: Scalars['ID']['input'];
+}>;
+export type ListAiAgentScenariosQuery = {
+    listAiAgentScenarios: Array<AiAgentScenarioFragment>;
+};
+export type SetAiAgentRetentionPolicyMutationVariables = Exact<{
+    input: AiAgentRetentionPolicyInput;
+}>;
+export type SetAiAgentRetentionPolicyMutation = {
+    setAiAgentRetentionPolicy: (Pick<AiAgentRetentionPolicy, 'masksPersonalData'> & {
+        days: Pick<AiAgentRetentionDays, 'transcript' | 'session_state' | 'long_term_memory'>;
+    });
+};
+export type AiAgentRetentionPolicyQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type AiAgentRetentionPolicyQuery = {
+    aiAgentRetentionPolicy: (Pick<AiAgentRetentionPolicy, 'masksPersonalData'> & {
+        days: Pick<AiAgentRetentionDays, 'transcript' | 'session_state' | 'long_term_memory'>;
+    });
+};
+export type AiAgentConversationMetricsQueryVariables = Exact<{
+    input: AiAgentMetricsInput;
+}>;
+export type AiAgentConversationMetricsQuery = {
+    aiAgentConversationMetrics: Array<Pick<AiAgentConversationMetrics, 'sessionId' | 'channel' | 'turns' | 'startedAt' | 'lastTurnAt' | 'totalTokens' | 'costMicroUsd' | 'durationMs' | 'lastOutcome'>>;
+};
+export type AiAgentConversationOutcomeQueryVariables = Exact<{
+    sessionId: Scalars['ID']['input'];
+}>;
+export type AiAgentConversationOutcomeQuery = {
+    aiAgentConversationOutcome?: Maybe<Pick<AiAgentConversationOutcome, 'sessionId' | 'agentId' | 'agentVersion' | 'resolution' | 'resolutionDefinition' | 'collectedData' | 'collectedDataAvailable' | 'turns' | 'startedAt' | 'lastTurnAt' | 'haltReason'>>;
+};
+export type SaveAiAgentUseCaseMutationVariables = Exact<{
+    input: SaveAiAgentUseCaseInput;
+}>;
+export type SaveAiAgentUseCaseMutation = {
+    saveAiAgentUseCase: AiAgentUseCaseFragment;
+};
+export type SaveAiAgentProcedureMutationVariables = Exact<{
+    input: SaveAiAgentProcedureInput;
+}>;
+export type SaveAiAgentProcedureMutation = {
+    saveAiAgentProcedure: AiAgentProcedureFragment;
+};
+export type RemoveAiAgentUseCaseMutationVariables = Exact<{
+    input: AiAgentAuthoringRefInput;
+}>;
+export type RemoveAiAgentUseCaseMutation = Pick<Mutation, 'removeAiAgentUseCase'>;
+export type RemoveAiAgentProcedureMutationVariables = Exact<{
+    input: AiAgentAuthoringRefInput;
+}>;
+export type RemoveAiAgentProcedureMutation = Pick<Mutation, 'removeAiAgentProcedure'>;
+export type ResolveAiAgentApprovalMutationVariables = Exact<{
+    input: ResolveAiAgentApprovalInput;
+}>;
+export type ResolveAiAgentApprovalMutation = Pick<Mutation, 'resolveAiAgentApproval'>;
+export type RegisterAiAgentToolMutationVariables = Exact<{
+    input: RegisterAiAgentToolInput;
+}>;
+export type RegisterAiAgentToolMutation = {
+    registerAiAgentTool?: Maybe<AiAgentToolFragment>;
+};
+export type UnregisterAiAgentToolMutationVariables = Exact<{
+    input: UnregisterAiAgentToolInput;
+}>;
+export type UnregisterAiAgentToolMutation = Pick<Mutation, 'unregisterAiAgentTool'>;
+export type SaveAiAgentScenarioMutationVariables = Exact<{
+    input: SaveAiAgentScenarioInput;
+}>;
+export type SaveAiAgentScenarioMutation = {
+    saveAiAgentScenario?: Maybe<AiAgentScenarioFragment>;
+};
+export type CheckAiAgentVersionMutationVariables = Exact<{
+    input: CheckAiAgentVersionInput;
+}>;
+export type CheckAiAgentVersionMutation = {
+    checkAiAgentVersion?: Maybe<(Pick<AiAgentCheckResult, 'safeToPublish'> & {
+        reports: Array<Pick<AiAgentScenarioReport, 'scenarioId' | 'runs' | 'passed' | 'rate'>>;
+        regressions: Array<Pick<AiAgentRegression, 'scenarioId' | 'before' | 'after'>>;
+    })>;
+};
+export type AiAgentMetricsReportFragment = (Pick<AiAgentMetrics, 'agentId' | 'from' | 'to' | 'truncated' | 'conversations' | 'conversationsResolved' | 'conversationsInconclusive' | 'conversationsHandoffRequested' | 'resolutionRate' | 'resolutionDefinition' | 'escalatedToHuman' | 'escalatedToFlow' | 'escalatedTargetUndeclared' | 'humanRequestedTurns' | 'costMicroUsd' | 'costMicroUsdPerResolvedConversation' | 'unpricedTurns' | 'inputTokens' | 'outputTokens' | 'totalTokens' | 'cachedInputTokens' | 'cachedTurns' | 'llmCalls' | 'avgTurnDurationMs' | 'p95TurnDurationMs' | 'avgLlmLatencyMs' | 'turns' | 'answeredTurns' | 'answeredWithFailedConnectionTurns' | 'unansweredTurns' | 'unansweredDefinition' | 'blockedTurns' | 'haltedTurns' | 'budgetExceededTurns' | 'identificationRequiredTurns' | 'toolCalls' | 'toolCallsFailed' | 'knowledgeRetrieved' | 'knowledgeEmpty' | 'knowledgeUnavailable' | 'knowledgeSkipped'> & {
+    handoffsByReason: Array<Pick<AiAgentMetricsCount, 'key' | 'count'>>;
+    turnsByModel: Array<Pick<AiAgentMetricsCount, 'key' | 'count'>>;
+    topTopics: Array<Pick<AiAgentMetricsCount, 'key' | 'count'>>;
+    topUnansweredQuestions: Array<Pick<AiAgentMetricsCount, 'key' | 'count'>>;
+    blocksByCategory: Array<Pick<AiAgentMetricsCount, 'key' | 'count'>>;
+    haltReasons: Array<Pick<AiAgentMetricsCount, 'key' | 'count'>>;
+    toolErrorsByConnection: Array<Pick<AiAgentMetricsCount, 'key' | 'count'>>;
+    toolErrorsByClass: Array<Pick<AiAgentMetricsCount, 'key' | 'count'>>;
+});
+export type AiAgentMetricsQueryVariables = Exact<{
+    input: AiAgentMetricsInput;
+}>;
+export type AiAgentMetricsQuery = {
+    aiAgentMetrics: AiAgentMetricsReportFragment;
+};
+export type AiAgentVersionSpecQueryVariables = Exact<{
+    agentId: Scalars['ID']['input'];
+}>;
+export type AiAgentVersionSpecQuery = {
+    listAiAgentVersions: Array<AiAgentVersionWithSpecFragment>;
+};
+export type AiAgentRoutingPreviewQueryVariables = Exact<{
+    input: AiAgentRoutingPreviewInput;
+}>;
+export type AiAgentRoutingPreviewQuery = {
+    aiAgentRoutingPreview: (Pick<AiAgentRoutingPreview, 'high' | 'medium'> & {
+        examples: Array<Pick<AiAgentRoutedExample, 'message' | 'useCaseId' | 'score' | 'confidence'>>;
+    });
+};
+export type AiAgentKnowledgeBasesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type AiAgentKnowledgeBasesQuery = {
+    aiAgentKnowledgeBases: Array<Pick<AiAgentKnowledgeBase, 'id' | 'title'>>;
+};
 export type ExtractImageMetadataMutationVariables = Exact<{
     input: ExtractImageMetadataInput;
 }>;
@@ -450,8 +1419,51 @@ export type RemoveQnAInstanceMutationVariables = Exact<{
 export type RemoveQnAInstanceMutation = {
     removeQnAInstance?: Maybe<QnaFragmentFragment>;
 };
+export declare const AiAgentSummaryFragmentDoc = "\n    fragment aiAgentSummary on AiAgentSummary {\n  agentId\n  name\n  liveVersion\n  channels\n  updatedAt\n  queuedApprovals\n  status\n}\n    ";
+export declare const AiAgentVersionFragmentDoc = "\n    fragment aiAgentVersion on AiAgentVersion {\n  agentId\n  version\n  status\n  createdAt\n}\n    ";
+export declare const AiAgentSpecFragmentDoc = "\n    fragment aiAgentSpec on AiAgentSpec {\n  identity {\n    displayName\n    role\n    tone\n    toneNotes\n    openingMessage\n    outOfScopeBehaviour\n  }\n  can\n  cannot\n  knowledgeBaseIds\n  knowledgeFallback\n  toolIds\n  budget {\n    maxSteps\n    maxToolCalls\n    maxTokens\n    maxCostMicroUsd\n    maxPeriodCostMicroUsd\n    onExceeded\n  }\n  handoff {\n    transition\n    target\n  }\n  channels\n}\n    ";
+export declare const AiAgentVersionWithSpecFragmentDoc = "\n    fragment aiAgentVersionWithSpec on AiAgentVersion {\n  agentId\n  version\n  status\n  createdAt\n  spec {\n    ...aiAgentSpec\n  }\n}\n    ";
+export declare const AiAgentListingMetricsFragmentDoc = "\n    fragment aiAgentListingMetrics on AiAgentMetrics {\n  agentId\n  conversations\n  conversationsResolved\n  conversationsHandoffRequested\n  resolutionRate\n  resolutionDefinition\n  costMicroUsd\n}\n    ";
+export declare const AiAgentUseCaseFragmentDoc = "\n    fragment aiAgentUseCase on AiAgentUseCase {\n  id\n  name\n  subjectDescription\n  procedureId\n  status\n  updatedAt\n}\n    ";
+export declare const AiAgentProcedureFragmentDoc = "\n    fragment aiAgentProcedure on AiAgentProcedure {\n  id\n  name\n  guidanceSteps\n  toolIds\n  contingency\n  executionAutonomy\n  status\n  updatedAt\n}\n    ";
+export declare const AiAgentToolFragmentDoc = "\n    fragment aiAgentTool on AiAgentTool {\n  toolId\n  name\n  description\n  effect\n  availability\n  requiresAuthenticatedCustomer\n  onFailure\n  customerScope\n  returns\n  approval\n  parameters {\n    name\n    type\n    required\n    description\n    grounding\n  }\n}\n    ";
+export declare const AiAgentTraceFragmentDoc = "\n    fragment aiAgentTrace on AiAgentTrace {\n  sessionId\n  turn\n  agentId\n  agentVersion\n  input\n  promptBuilderVersion\n  masterRuleVersion\n  identificationRequired\n  promptFingerprint\n  knowledgeOrigins\n  outcome\n  haltReason\n  steps\n  answer\n  startedAt\n  toolCalls {\n    toolId\n    name\n    result\n    ok\n    connection\n    errorClass\n  }\n}\n    ";
+export declare const AiAgentScenarioFragmentDoc = "\n    fragment aiAgentScenario on AiAgentScenario {\n  scenarioId\n  description\n  turns\n  expectations\n}\n    ";
+export declare const AiAgentMetricsReportFragmentDoc = "\n    fragment aiAgentMetricsReport on AiAgentMetrics {\n  agentId\n  from\n  to\n  truncated\n  conversations\n  conversationsResolved\n  conversationsInconclusive\n  conversationsHandoffRequested\n  resolutionRate\n  resolutionDefinition\n  escalatedToHuman\n  escalatedToFlow\n  escalatedTargetUndeclared\n  handoffsByReason {\n    key\n    count\n  }\n  humanRequestedTurns\n  costMicroUsd\n  costMicroUsdPerResolvedConversation\n  unpricedTurns\n  inputTokens\n  outputTokens\n  totalTokens\n  cachedInputTokens\n  cachedTurns\n  llmCalls\n  turnsByModel {\n    key\n    count\n  }\n  avgTurnDurationMs\n  p95TurnDurationMs\n  avgLlmLatencyMs\n  turns\n  answeredTurns\n  answeredWithFailedConnectionTurns\n  unansweredTurns\n  unansweredDefinition\n  topTopics {\n    key\n    count\n  }\n  topUnansweredQuestions {\n    key\n    count\n  }\n  blockedTurns\n  blocksByCategory {\n    key\n    count\n  }\n  haltedTurns\n  haltReasons {\n    key\n    count\n  }\n  budgetExceededTurns\n  identificationRequiredTurns\n  toolCalls\n  toolCallsFailed\n  toolErrorsByConnection {\n    key\n    count\n  }\n  toolErrorsByClass {\n    key\n    count\n  }\n  knowledgeRetrieved\n  knowledgeEmpty\n  knowledgeUnavailable\n  knowledgeSkipped\n}\n    ";
 export declare const NlpInstanceFragmentDoc = "\n    fragment nlpInstance on NlpInstance {\n  id\n  name\n  drn\n  options {\n    transition\n    samples\n  }\n  createdAt\n  updatedAt\n}\n    ";
 export declare const QnaFragmentFragmentDoc = "\n    fragment qnaFragment on QnAInstance {\n  id\n  name\n  drn\n  credentialsId\n  tryToReplyOnTransition\n  createdAt\n  updatedAt\n}\n    ";
+export declare const ListAiAgentsDocument = "\n    query listAiAgents {\n  listAiAgents {\n    ...aiAgentSummary\n  }\n}\n    \n    fragment aiAgentSummary on AiAgentSummary {\n  agentId\n  name\n  liveVersion\n  channels\n  updatedAt\n  queuedApprovals\n  status\n}\n    ";
+export declare const ListAiAgentVersionsDocument = "\n    query listAiAgentVersions($agentId: ID!) {\n  listAiAgentVersions(agentId: $agentId) {\n    ...aiAgentVersion\n  }\n}\n    \n    fragment aiAgentVersion on AiAgentVersion {\n  agentId\n  version\n  status\n  createdAt\n}\n    ";
+export declare const AiAgentMetricsByAgentDocument = "\n    query aiAgentMetricsByAgent($input: AiAgentMetricsWindowInput!) {\n  aiAgentMetricsByAgent(input: $input) {\n    ...aiAgentListingMetrics\n  }\n}\n    \n    fragment aiAgentListingMetrics on AiAgentMetrics {\n  agentId\n  conversations\n  conversationsResolved\n  conversationsHandoffRequested\n  resolutionRate\n  resolutionDefinition\n  costMicroUsd\n}\n    ";
+export declare const DraftAiAgentDocument = "\n    mutation draftAiAgent($input: DraftAiAgentInput!) {\n  draftAiAgent(input: $input) {\n    ...aiAgentVersion\n  }\n}\n    \n    fragment aiAgentVersion on AiAgentVersion {\n  agentId\n  version\n  status\n  createdAt\n}\n    ";
+export declare const PublishAiAgentVersionDocument = "\n    mutation publishAiAgentVersion($input: AiAgentVersionRefInput!) {\n  publishAiAgentVersion(input: $input) {\n    ...aiAgentVersion\n  }\n}\n    \n    fragment aiAgentVersion on AiAgentVersion {\n  agentId\n  version\n  status\n  createdAt\n}\n    ";
+export declare const UnpublishAiAgentVersionDocument = "\n    mutation unpublishAiAgentVersion($input: AiAgentVersionRefInput!) {\n  unpublishAiAgentVersion(input: $input) {\n    ...aiAgentVersion\n  }\n}\n    \n    fragment aiAgentVersion on AiAgentVersion {\n  agentId\n  version\n  status\n  createdAt\n}\n    ";
+export declare const RollbackAiAgentVersionDocument = "\n    mutation rollbackAiAgentVersion($input: AiAgentVersionRefInput!) {\n  rollbackAiAgentVersion(input: $input) {\n    ...aiAgentVersion\n  }\n}\n    \n    fragment aiAgentVersion on AiAgentVersion {\n  agentId\n  version\n  status\n  createdAt\n}\n    ";
+export declare const RemoveAiAgentVersionDocument = "\n    mutation removeAiAgentVersion($input: AiAgentVersionRefInput!) {\n  removeAiAgentVersion(input: $input) {\n    ...aiAgentVersion\n  }\n}\n    \n    fragment aiAgentVersion on AiAgentVersion {\n  agentId\n  version\n  status\n  createdAt\n}\n    ";
+export declare const RemoveAiAgentDocument = "\n    mutation removeAiAgent($input: AiAgentRefInput!) {\n  removeAiAgent(input: $input)\n}\n    ";
+export declare const ListAiAgentUseCasesDocument = "\n    query listAiAgentUseCases($agentId: ID!) {\n  listAiAgentUseCases(agentId: $agentId) {\n    ...aiAgentUseCase\n  }\n}\n    \n    fragment aiAgentUseCase on AiAgentUseCase {\n  id\n  name\n  subjectDescription\n  procedureId\n  status\n  updatedAt\n}\n    ";
+export declare const ListAiAgentProceduresDocument = "\n    query listAiAgentProcedures($agentId: ID!) {\n  listAiAgentProcedures(agentId: $agentId) {\n    ...aiAgentProcedure\n  }\n}\n    \n    fragment aiAgentProcedure on AiAgentProcedure {\n  id\n  name\n  guidanceSteps\n  toolIds\n  contingency\n  executionAutonomy\n  status\n  updatedAt\n}\n    ";
+export declare const ListAiAgentToolsDocument = "\n    query listAiAgentTools {\n  listAiAgentTools {\n    ...aiAgentTool\n  }\n}\n    \n    fragment aiAgentTool on AiAgentTool {\n  toolId\n  name\n  description\n  effect\n  availability\n  requiresAuthenticatedCustomer\n  onFailure\n  customerScope\n  returns\n  approval\n  parameters {\n    name\n    type\n    required\n    description\n    grounding\n  }\n}\n    ";
+export declare const AiAgentUseCaseOverlapDocument = "\n    query aiAgentUseCaseOverlap($agentId: ID!) {\n  aiAgentUseCaseOverlap(agentId: $agentId) {\n    threshold\n    pairs {\n      left\n      right\n      score\n    }\n  }\n}\n    ";
+export declare const AiAgentTraceDocument = "\n    query aiAgentTrace($sessionId: ID!) {\n  aiAgentTrace(sessionId: $sessionId) {\n    ...aiAgentTrace\n  }\n}\n    \n    fragment aiAgentTrace on AiAgentTrace {\n  sessionId\n  turn\n  agentId\n  agentVersion\n  input\n  promptBuilderVersion\n  masterRuleVersion\n  identificationRequired\n  promptFingerprint\n  knowledgeOrigins\n  outcome\n  haltReason\n  steps\n  answer\n  startedAt\n  toolCalls {\n    toolId\n    name\n    result\n    ok\n    connection\n    errorClass\n  }\n}\n    ";
+export declare const ListAiAgentScenariosDocument = "\n    query listAiAgentScenarios($agentId: ID!) {\n  listAiAgentScenarios(agentId: $agentId) {\n    ...aiAgentScenario\n  }\n}\n    \n    fragment aiAgentScenario on AiAgentScenario {\n  scenarioId\n  description\n  turns\n  expectations\n}\n    ";
+export declare const SetAiAgentRetentionPolicyDocument = "\n    mutation setAiAgentRetentionPolicy($input: AiAgentRetentionPolicyInput!) {\n  setAiAgentRetentionPolicy(input: $input) {\n    days {\n      transcript\n      session_state\n      long_term_memory\n    }\n    masksPersonalData\n  }\n}\n    ";
+export declare const AiAgentRetentionPolicyDocument = "\n    query aiAgentRetentionPolicy {\n  aiAgentRetentionPolicy {\n    days {\n      transcript\n      session_state\n      long_term_memory\n    }\n    masksPersonalData\n  }\n}\n    ";
+export declare const AiAgentConversationMetricsDocument = "\n    query aiAgentConversationMetrics($input: AiAgentMetricsInput!) {\n  aiAgentConversationMetrics(input: $input) {\n    sessionId\n    channel\n    turns\n    startedAt\n    lastTurnAt\n    totalTokens\n    costMicroUsd\n    durationMs\n    lastOutcome\n  }\n}\n    ";
+export declare const AiAgentConversationOutcomeDocument = "\n    query aiAgentConversationOutcome($sessionId: ID!) {\n  aiAgentConversationOutcome(sessionId: $sessionId) {\n    sessionId\n    agentId\n    agentVersion\n    resolution\n    resolutionDefinition\n    collectedData\n    collectedDataAvailable\n    turns\n    startedAt\n    lastTurnAt\n    haltReason\n  }\n}\n    ";
+export declare const SaveAiAgentUseCaseDocument = "\n    mutation saveAiAgentUseCase($input: SaveAiAgentUseCaseInput!) {\n  saveAiAgentUseCase(input: $input) {\n    ...aiAgentUseCase\n  }\n}\n    \n    fragment aiAgentUseCase on AiAgentUseCase {\n  id\n  name\n  subjectDescription\n  procedureId\n  status\n  updatedAt\n}\n    ";
+export declare const SaveAiAgentProcedureDocument = "\n    mutation saveAiAgentProcedure($input: SaveAiAgentProcedureInput!) {\n  saveAiAgentProcedure(input: $input) {\n    ...aiAgentProcedure\n  }\n}\n    \n    fragment aiAgentProcedure on AiAgentProcedure {\n  id\n  name\n  guidanceSteps\n  toolIds\n  contingency\n  executionAutonomy\n  status\n  updatedAt\n}\n    ";
+export declare const RemoveAiAgentUseCaseDocument = "\n    mutation removeAiAgentUseCase($input: AiAgentAuthoringRefInput!) {\n  removeAiAgentUseCase(input: $input)\n}\n    ";
+export declare const RemoveAiAgentProcedureDocument = "\n    mutation removeAiAgentProcedure($input: AiAgentAuthoringRefInput!) {\n  removeAiAgentProcedure(input: $input)\n}\n    ";
+export declare const ResolveAiAgentApprovalDocument = "\n    mutation resolveAiAgentApproval($input: ResolveAiAgentApprovalInput!) {\n  resolveAiAgentApproval(input: $input)\n}\n    ";
+export declare const RegisterAiAgentToolDocument = "\n    mutation registerAiAgentTool($input: RegisterAiAgentToolInput!) {\n  registerAiAgentTool(input: $input) {\n    ...aiAgentTool\n  }\n}\n    \n    fragment aiAgentTool on AiAgentTool {\n  toolId\n  name\n  description\n  effect\n  availability\n  requiresAuthenticatedCustomer\n  onFailure\n  customerScope\n  returns\n  approval\n  parameters {\n    name\n    type\n    required\n    description\n    grounding\n  }\n}\n    ";
+export declare const UnregisterAiAgentToolDocument = "\n    mutation unregisterAiAgentTool($input: UnregisterAiAgentToolInput!) {\n  unregisterAiAgentTool(input: $input)\n}\n    ";
+export declare const SaveAiAgentScenarioDocument = "\n    mutation saveAiAgentScenario($input: SaveAiAgentScenarioInput!) {\n  saveAiAgentScenario(input: $input) {\n    ...aiAgentScenario\n  }\n}\n    \n    fragment aiAgentScenario on AiAgentScenario {\n  scenarioId\n  description\n  turns\n  expectations\n}\n    ";
+export declare const CheckAiAgentVersionDocument = "\n    mutation checkAiAgentVersion($input: CheckAiAgentVersionInput!) {\n  checkAiAgentVersion(input: $input) {\n    safeToPublish\n    reports {\n      scenarioId\n      runs\n      passed\n      rate\n    }\n    regressions {\n      scenarioId\n      before\n      after\n    }\n  }\n}\n    ";
+export declare const AiAgentMetricsDocument = "\n    query aiAgentMetrics($input: AiAgentMetricsInput!) {\n  aiAgentMetrics(input: $input) {\n    ...aiAgentMetricsReport\n  }\n}\n    \n    fragment aiAgentMetricsReport on AiAgentMetrics {\n  agentId\n  from\n  to\n  truncated\n  conversations\n  conversationsResolved\n  conversationsInconclusive\n  conversationsHandoffRequested\n  resolutionRate\n  resolutionDefinition\n  escalatedToHuman\n  escalatedToFlow\n  escalatedTargetUndeclared\n  handoffsByReason {\n    key\n    count\n  }\n  humanRequestedTurns\n  costMicroUsd\n  costMicroUsdPerResolvedConversation\n  unpricedTurns\n  inputTokens\n  outputTokens\n  totalTokens\n  cachedInputTokens\n  cachedTurns\n  llmCalls\n  turnsByModel {\n    key\n    count\n  }\n  avgTurnDurationMs\n  p95TurnDurationMs\n  avgLlmLatencyMs\n  turns\n  answeredTurns\n  answeredWithFailedConnectionTurns\n  unansweredTurns\n  unansweredDefinition\n  topTopics {\n    key\n    count\n  }\n  topUnansweredQuestions {\n    key\n    count\n  }\n  blockedTurns\n  blocksByCategory {\n    key\n    count\n  }\n  haltedTurns\n  haltReasons {\n    key\n    count\n  }\n  budgetExceededTurns\n  identificationRequiredTurns\n  toolCalls\n  toolCallsFailed\n  toolErrorsByConnection {\n    key\n    count\n  }\n  toolErrorsByClass {\n    key\n    count\n  }\n  knowledgeRetrieved\n  knowledgeEmpty\n  knowledgeUnavailable\n  knowledgeSkipped\n}\n    ";
+export declare const AiAgentVersionSpecDocument = "\n    query aiAgentVersionSpec($agentId: ID!) {\n  listAiAgentVersions(agentId: $agentId) {\n    ...aiAgentVersionWithSpec\n  }\n}\n    \n    fragment aiAgentVersionWithSpec on AiAgentVersion {\n  agentId\n  version\n  status\n  createdAt\n  spec {\n    ...aiAgentSpec\n  }\n}\n    \n\n    fragment aiAgentSpec on AiAgentSpec {\n  identity {\n    displayName\n    role\n    tone\n    toneNotes\n    openingMessage\n    outOfScopeBehaviour\n  }\n  can\n  cannot\n  knowledgeBaseIds\n  knowledgeFallback\n  toolIds\n  budget {\n    maxSteps\n    maxToolCalls\n    maxTokens\n    maxCostMicroUsd\n    maxPeriodCostMicroUsd\n    onExceeded\n  }\n  handoff {\n    transition\n    target\n  }\n  channels\n}\n    ";
+export declare const AiAgentRoutingPreviewDocument = "\n    query aiAgentRoutingPreview($input: AiAgentRoutingPreviewInput!) {\n  aiAgentRoutingPreview(input: $input) {\n    high\n    medium\n    examples {\n      message\n      useCaseId\n      score\n      confidence\n    }\n  }\n}\n    ";
+export declare const AiAgentKnowledgeBasesDocument = "\n    query aiAgentKnowledgeBases {\n  aiAgentKnowledgeBases {\n    id\n    title\n  }\n}\n    ";
 export declare const ExtractImageMetadataDocument = "\n    mutation extractImageMetadata($input: ExtractImageMetadataInput!) {\n  extractImageMetadata(input: $input) {\n    success\n    model\n    extractedMetadata\n    tokenUsage {\n      prompt\n      completion\n      total\n    }\n  }\n}\n    ";
 export declare const GetNlpInstanceDocument = "\n    query getNlpInstance($id: ID!) {\n  getNlpInstance(id: $id) {\n    ...nlpInstance\n  }\n}\n    \n    fragment nlpInstance on NlpInstance {\n  id\n  name\n  drn\n  options {\n    transition\n    samples\n  }\n  createdAt\n  updatedAt\n}\n    ";
 export declare const ListNlpInstancesDocument = "\n    query listNlpInstances {\n  listNlpInstances {\n    ...nlpInstance\n  }\n}\n    \n    fragment nlpInstance on NlpInstance {\n  id\n  name\n  drn\n  options {\n    transition\n    samples\n  }\n  createdAt\n  updatedAt\n}\n    ";
@@ -467,6 +1479,38 @@ export declare const UpdateQnAInstanceDocument = "\n    mutation updateQnAInstan
 export declare const RemoveQnAInstanceDocument = "\n    mutation removeQnAInstance($input: RemoveQnAInstanceInput!) {\n  removeQnAInstance(input: $input) {\n    ...qnaFragment\n  }\n}\n    \n    fragment qnaFragment on QnAInstance {\n  id\n  name\n  drn\n  credentialsId\n  tryToReplyOnTransition\n  createdAt\n  updatedAt\n}\n    ";
 export type Requester<C = {}> = <R, V>(doc: string, vars?: V, options?: C) => Promise<R> | AsyncIterableIterator<R>;
 export declare function getSdk<C>(requester: Requester<C>): {
+    listAiAgents(variables?: ListAiAgentsQueryVariables, options?: C): Promise<ListAiAgentsQuery>;
+    listAiAgentVersions(variables: ListAiAgentVersionsQueryVariables, options?: C): Promise<ListAiAgentVersionsQuery>;
+    aiAgentMetricsByAgent(variables: AiAgentMetricsByAgentQueryVariables, options?: C): Promise<AiAgentMetricsByAgentQuery>;
+    draftAiAgent(variables: DraftAiAgentMutationVariables, options?: C): Promise<DraftAiAgentMutation>;
+    publishAiAgentVersion(variables: PublishAiAgentVersionMutationVariables, options?: C): Promise<PublishAiAgentVersionMutation>;
+    unpublishAiAgentVersion(variables: UnpublishAiAgentVersionMutationVariables, options?: C): Promise<UnpublishAiAgentVersionMutation>;
+    rollbackAiAgentVersion(variables: RollbackAiAgentVersionMutationVariables, options?: C): Promise<RollbackAiAgentVersionMutation>;
+    removeAiAgentVersion(variables: RemoveAiAgentVersionMutationVariables, options?: C): Promise<RemoveAiAgentVersionMutation>;
+    removeAiAgent(variables: RemoveAiAgentMutationVariables, options?: C): Promise<RemoveAiAgentMutation>;
+    listAiAgentUseCases(variables: ListAiAgentUseCasesQueryVariables, options?: C): Promise<ListAiAgentUseCasesQuery>;
+    listAiAgentProcedures(variables: ListAiAgentProceduresQueryVariables, options?: C): Promise<ListAiAgentProceduresQuery>;
+    listAiAgentTools(variables?: ListAiAgentToolsQueryVariables, options?: C): Promise<ListAiAgentToolsQuery>;
+    aiAgentUseCaseOverlap(variables: AiAgentUseCaseOverlapQueryVariables, options?: C): Promise<AiAgentUseCaseOverlapQuery>;
+    aiAgentTrace(variables: AiAgentTraceQueryVariables, options?: C): Promise<AiAgentTraceQuery>;
+    listAiAgentScenarios(variables: ListAiAgentScenariosQueryVariables, options?: C): Promise<ListAiAgentScenariosQuery>;
+    setAiAgentRetentionPolicy(variables: SetAiAgentRetentionPolicyMutationVariables, options?: C): Promise<SetAiAgentRetentionPolicyMutation>;
+    aiAgentRetentionPolicy(variables?: AiAgentRetentionPolicyQueryVariables, options?: C): Promise<AiAgentRetentionPolicyQuery>;
+    aiAgentConversationMetrics(variables: AiAgentConversationMetricsQueryVariables, options?: C): Promise<AiAgentConversationMetricsQuery>;
+    aiAgentConversationOutcome(variables: AiAgentConversationOutcomeQueryVariables, options?: C): Promise<AiAgentConversationOutcomeQuery>;
+    saveAiAgentUseCase(variables: SaveAiAgentUseCaseMutationVariables, options?: C): Promise<SaveAiAgentUseCaseMutation>;
+    saveAiAgentProcedure(variables: SaveAiAgentProcedureMutationVariables, options?: C): Promise<SaveAiAgentProcedureMutation>;
+    removeAiAgentUseCase(variables: RemoveAiAgentUseCaseMutationVariables, options?: C): Promise<RemoveAiAgentUseCaseMutation>;
+    removeAiAgentProcedure(variables: RemoveAiAgentProcedureMutationVariables, options?: C): Promise<RemoveAiAgentProcedureMutation>;
+    resolveAiAgentApproval(variables: ResolveAiAgentApprovalMutationVariables, options?: C): Promise<ResolveAiAgentApprovalMutation>;
+    registerAiAgentTool(variables: RegisterAiAgentToolMutationVariables, options?: C): Promise<RegisterAiAgentToolMutation>;
+    unregisterAiAgentTool(variables: UnregisterAiAgentToolMutationVariables, options?: C): Promise<UnregisterAiAgentToolMutation>;
+    saveAiAgentScenario(variables: SaveAiAgentScenarioMutationVariables, options?: C): Promise<SaveAiAgentScenarioMutation>;
+    checkAiAgentVersion(variables: CheckAiAgentVersionMutationVariables, options?: C): Promise<CheckAiAgentVersionMutation>;
+    aiAgentMetrics(variables: AiAgentMetricsQueryVariables, options?: C): Promise<AiAgentMetricsQuery>;
+    aiAgentVersionSpec(variables: AiAgentVersionSpecQueryVariables, options?: C): Promise<AiAgentVersionSpecQuery>;
+    aiAgentRoutingPreview(variables: AiAgentRoutingPreviewQueryVariables, options?: C): Promise<AiAgentRoutingPreviewQuery>;
+    aiAgentKnowledgeBases(variables?: AiAgentKnowledgeBasesQueryVariables, options?: C): Promise<AiAgentKnowledgeBasesQuery>;
     extractImageMetadata(variables: ExtractImageMetadataMutationVariables, options?: C): Promise<ExtractImageMetadataMutation>;
     getNlpInstance(variables: GetNlpInstanceQueryVariables, options?: C): Promise<GetNlpInstanceQuery>;
     listNlpInstances(variables?: ListNlpInstancesQueryVariables, options?: C): Promise<ListNlpInstancesQuery>;