Para agentes de IA: um índice de documentação está disponível em https://www.mongodb.com/pt-br/docs/llms.txt — as versões de markdown de todas as páginas estão disponíveis anexando .md a qualquer caminho de URL.
See how MongoDB 9.0 delivers up to 2x higher throughput.
MongoDB Branding Shape
Register now >
Menu Docs
Página inicial do Docs
/ /
Agent-engine-sdk
Página inicial do Docs
/ /
JavaScript SDK
/
Agent-engine-sdk
Página inicial do Docs
/
Mecanismo do Atlas Agent
/
Atlas Agent Engine SDK
/
JavaScript SDK
/
Agent-engine-sdk

@mongodb-js/agent-engine-sdk

Sumário

Aulas

abstract BaseApp

classe de base abstrata para integrações de SDK específicas de framework.

Cada SDK de framework (LangGraph, CrewAI, etc.) subclassifica BaseApp e implementa os métodos abstratos usando construções nativas de framework.

O tempo de execução da plataforma define toolWrapper e llmWrapper na instância antes de chamar entrypoint() para que as ferramentas e os LLMs sejam roteados através da camada de execução segura.

Constructor

new BaseApp(name): BaseApp;

Parâmetros

Parâmetro
Tipo

name

string

Devoluções

`BaseApp <#abstract-baseapp>'__

Propriedades

Propriedade
Modifier
Tipo
Valor padrão

llmWrapper

public

unknown

null

name

readonly

string

undefined

toolWrapper

public

unknown

null

Métodos

ponto de entrada()
abstract entrypoint(fn): unknown;

Construtor que registra a função do agente construtor. Chamado pelos tempos de execução para obter um BaseAgent.

Parâmetros

Parâmetro
Tipo

fn

unknown

Devoluções

unknown

getToolDefinitions()
abstract getToolDefinitions(): object[];

Retorna todas as definições de ferramenta registradas. Usado pelo OE para obter informações de execução da ferramenta.

Devoluções

object []

ferramenta()
abstract tool(...args): unknown;

Construtor que registra uma ferramenta neste aplicativo.

Parâmetros

Parâmetro
Tipo

… args

unknown []

Devoluções

unknown

ferramentas()
abstract tools(): unknown[];

Retorna uma lista de ferramentas específicas da estrutura agrupadas.

Devoluções

unknown []

Cliente de evento

Constructor

new EventClient(oeUrl, timeout?): EventClient;

Parâmetros

Parâmetro
Tipo
Valor padrão

oeUrl

string

undefined

timeout

number

30

Devoluções

`EventClient <#eventclient>`__

Métodos

appendEvent()
appendEvent(
   sessionId,
   actorId,
   payload,
   parentEventId?,
   metadata?,
   branch?
): Promise<{
[key: string]: unknown;
  actor_id: string;
  branch?: {
   [key: string]: unknown;
     name: string;
     root_event_id: string;
  };
  event_id: string;
  metadata?: Record<string, string>;
  parent_event_id?: string;
  payload:   | string
     | number
     | boolean
     | JsonValue[]
     | {
   [key: string]: JsonValue;
   }
     | null;
  session_id: string;
  timestamp: Date;
}>;

Parâmetros

Parâmetro
Tipo

sessionId

string

actorId

string

payload

Record <string, unknown>

parentEventId?

string

metadata?

Record <string, unknown>

branch?

{ [key: string]: unknown; name: string; root_event_id: string; }

branch.name?

string

branch.root_event_id?

string

Devoluções

Promise <{ [key: string]: unknown; actor_id: string; branch?: { [key: string]: unknown; name: string; root_event_id: string; }; event_id: string; metadata?: Record <string, string>; parent_event_id?: string; payload: | string | number | boolean | `JsonValue <#jsonvalue>`__ [] | { [key: string]: `JsonValue <#jsonvalue>`__; } | null; session_id: string; timestamp: Date; }>

getEvent()
getEvent(sessionId, eventId): Promise<
  | {
[key: string]: unknown;
  actor_id: string;
  branch?: {
   [key: string]: unknown;
     name: string;
     root_event_id: string;
  };
  event_id: string;
  metadata?: Record<string, string>;
  parent_event_id?: string;
  payload:   | string
     | number
     | boolean
     | JsonValue[]
     | {
   [key: string]: JsonValue;
   }
     | null;
  session_id: string;
  timestamp: Date;
}
| null>;

Parâmetros

Parâmetro
Tipo

sessionId

string

eventId

string

Devoluções

Promise < | { [key: string]: unknown; actor_id: string; branch?: { [key: string]: unknown; name: string; root_event_id: string; }; event_id: string; metadata?: Record <string, string>; parent_event_id?: string; payload: | string | number | boolean | `JsonValue <#jsonvalue>`__ [] | { [key: string]: `JsonValue <#jsonvalue>`__; } | null; session_id: string; timestamp: Date; } | null>

listEvents()
listEvents(
   sessionId,
   branch?,
   metadataFilters?
): Promise<object[]>;

Parâmetros

Parâmetro
Tipo

sessionId

string

branch?

string

metadataFilters?

Record <string, string>

Devoluções

Promise <object []>

LLMInvocaçãoOptions

Opções explícitas de provedor/modelo passadas com uma invocação LLM.

Constructor

new LLMInvocationOptions(data): LLMInvocationOptions;

Parâmetros

Parâmetro
Tipo

data

{ [key: string]: unknown; frequency_penalty?: number; max_tokens?: number; parallel_tool_calls?: boolean; presence_penalty?: number; reasoning_effort?: string; response_format?: `JsonValue <#jsonvalue>`__; seed?: number; timeout?: number; top_k?: number; top_p?: number; }

data.frequency_penalty?

number

data.max_tokens?

number

data.parallel_tool_calls?

boolean

data.presence_penalty?

number

data.reasoning_effort?

string

data.response_format?

`JsonValue <#jsonvalue>`__

data.seed?

number

data.timeout?

number

data.top_k?

number

data.top_p?

number

Devoluções

`LLMInvocationOptions <#llmin preferenceoptions>`__

Propriedades

Propriedade
Modifier
Tipo
Descrição

extras

readonly

Record <string, unknown>

Kwares específicos do fornecedor que não estão no conjunto de campo padrão (por exemplo, temperatura). Espelha o extra= “permitir” do Python.

frequencyPenalty?

readonly

number

maxTokens?

readonly

number

parallelToolCalls?

readonly

boolean

presencePenalty?

readonly

number

reasoningEffort?

readonly

string

responseFormat?

readonly

`JsonValue <#jsonvalue>`__

seed?

readonly

number

timeout?

readonly

number

topK?

readonly

number

topP?

readonly

number

Métodos

toJSON()
toJSON(): Record<string, unknown>;

Serializa para o formato de fio snake_case para que JSON.stringify viaje de ida e volta por meio do LLMIn preferenceOptionsSchema.

Devoluções

Record <string, unknown>

toModelKservices()
toModelKwargs(): Record<string, unknown>;

Converte para kvarg para invocação de modelo subjacente. Espelha o model_dump(exclude_none=True) do Python com extra="allow".

Devoluções

Record <string, unknown>

Resposta do LLM

Resposta LLM neutro em relação à estrutura.

Constructor

new LLMResponse(data): LLMResponse;

Parâmetros

Parâmetro
Tipo

data

{ additionalKwargs?: Record <string, `JsonValue <#jsonvalue>`__>; content: string; id?: string; metadata?: Record <string, `JsonValue <#jsonvalue>`__>; name?: string; responseMetadata?: Record <string, `JsonValue <#jsonvalue>`__>; toolCalls?: `LLMToolCall <#llmtoolcall>`__ []; usage?: `LLMTokenUsage <#llmtokenusage>`__; }

data.additionalKwargs?

Record <string, `JsonValue <#jsonvalue>`__>

data.content

string

data.id?

string

data.metadata?

Record <string, `JsonValue <#jsonvalue>`__>

data.name?

string

data.responseMetadata?

Record <string, `JsonValue <#jsonvalue>`__>

data.toolCalls?

`LLMToolCall <#llmtoolcall>`__ []

data.usage?

`LLMTokenUsage <#llmtokenusage>`__

Devoluções

`LLMResponse <#llmresponse>`__

Propriedades

Propriedade
Modifier
Tipo

additionalKwargs?

readonly

Record <string, `JsonValue <#jsonvalue>`__>

content

readonly

string

id?

readonly

string

metadata

readonly

Record <string, `JsonValue <#jsonvalue>`__>

name?

readonly

string

responseMetadata?

readonly

Record <string, `JsonValue <#jsonvalue>`__>

toolCalls?

readonly

`LLMToolCall <#llmtoolcall>`__ []

usage?

readonly

`LLMTokenUsage <#llmtokenusage>`__

Métodos

fromRaw()
static fromRaw(data): LLMResponse;

Constrói um LLMResponse a partir de um dicionário bruto do fornecedor, normalizando o uso de uma chave de " uso " de nível superior ou de chaves de token incorporadas em " metadados ".

Parâmetros

Parâmetro
Tipo

data

Record <string, unknown>

Devoluções

`LLMResponse <#llmresponse>`__

LLMTokenUsage

Metadados de uso de token digitados para chamadas LLM.

Constructor

new LLMTokenUsage(data): LLMTokenUsage;

Parâmetros

Parâmetro
Tipo

data

{ completion_tokens?: number; input_tokens?: number; model?: string; output_tokens?: number; prompt_tokens?: number; total_tokens?: number; }

data.completion_tokens?

number

data.input_tokens?

number

data.model?

string

data.output_tokens?

number

data.prompt_tokens?

number

data.total_tokens?

number

Devoluções

`LLMTokenUsage <#llmtokenusage>`__

Propriedades

Propriedade
Modifier
Tipo

completionTokens?

readonly

number

inputTokens?

readonly

number

model?

readonly

string

outputTokens?

readonly

number

promptTokens?

readonly

number

totalTokens?

public

number

Métodos

toJSON()
toJSON(): Record<string, unknown>;

Serializa para o formato de fio snake_case para que JSON.stringify ida e volta através de LLMTokenUsageSchema.

Devoluções

Record <string, unknown>

toLangchainUsageMetadata()
toLangchainUsageMetadata(): object;

Retorna as chaves de metadados de uso esperadas do LangChain.

Devoluções

object

Nome
Tipo

input_tokens

number

output_tokens

number

total_tokens

number

LLMToolCall

Chamada de ferramenta final digitada solicitada por um LLM.

Constructor

new LLMToolCall(data): LLMToolCall;

Parâmetros

Parâmetro
Tipo

data

{ args?: `JsonValue <#jsonvalue>`__; arguments?: `JsonValue <#jsonvalue>`__; id?: string; index?: number; name?: string; type?: string; }

data.args?

`JsonValue <#jsonvalue>`__

data.arguments?

`JsonValue <#jsonvalue>`__

data.id?

string

data.index?

number

data.name?

string

data.type?

string

Devoluções

`LLMToolCall <#llmtoolcall>`__

Propriedades

Propriedade
Modifier
Tipo

args?

readonly

`JsonValue <#jsonvalue>`__

id?

readonly

string

index?

readonly

number

name?

readonly

string

type?

readonly

string

Métodos

toLangchainDict()
toLangchainDict(): Record<string, JsonValue>;

Retorna um dicionário de chamada de ferramenta compatível com LangChain (exclui índice).

Devoluções

Record <string, `JsonValue <#jsonvalue>`__>

LLMToolSchema

Esquema de ferramenta de limite serializável encaminhado com uma chamada LLM.

Constructor

new LLMToolSchema(data): LLMToolSchema;

Parâmetros

Parâmetro
Tipo

data

{ description?: string; function?: `JsonValue <#jsonvalue>`__; name?: string; parameters?: `JsonValue <#jsonvalue>`__; strict?: boolean; type?: string; }

data.description?

string

data.function?

`JsonValue <#jsonvalue>`__

data.name?

string

data.parameters?

`JsonValue <#jsonvalue>`__

data.strict?

boolean

data.type?

string

Devoluções

`LLMToolSchema <#llmtoolschema>`__

Propriedades

Propriedade
Modifier
Tipo

description?

readonly

string

function?

readonly

`JsonValue <#jsonvalue>`__

name?

readonly

string

parameters?

readonly

`JsonValue <#jsonvalue>`__

strict?

readonly

boolean

type?

readonly

string

Métodos

toLangchainDict()
toLangchainDict(): Record<string, JsonValue>;

Retorna o esquema na forma que o LangChain bind_tools espera.

Devoluções

Record <string, `JsonValue <#jsonvalue>`__>

Cliente de memória

cliente HTTP para o Servidor de Memória.

const client = new MemoryClient('http://127.0.0.1:8081')
// Write conversation turn
await client.writeTurn({ sessionId: 'thread_123', role: 'user', content: 'Hello', orgId: 'org_1', userId: 'user_1', projectId: 'proj_1' })
// Build context
const context = await client.buildContext({ query: 'What did we discuss?', sessionId: 'thread_123', orgId: 'org_1', userId: 'user_1', projectId: 'proj_1' })

Constructor

new MemoryClient(
   baseUrl,
   timeout?,
   staticHeaders?,
   apiPrefix?,
   dynamicHeaders?,
   requestExtras?,
   maxRetries?,
   routeStyle?,
   fetchImpl?
): MemoryClient;

Parâmetros

Parâmetro
Tipo
Valor padrão
Descrição

baseUrl

string

undefined

Memory server base URL (e.g. “http://127.0.0.1:8081”)

timeout

number

30

Solicitar tempo limite em segundos (padrão: 30)

staticHeaders

Record <string, string>

{}

Cabeçalhos de identidade no nível do pod definidos no momento da construção (por exemplo, X-Agent-Engine-Agent-Id do App_ID). As mutações de então chamador copiadas defensivamente após a construção não têm efeito.

apiPrefix

string

"/api/v1/memory"

Prefixo de caminho URL para pontos de conexão de memória. O padrão é "/api/v1/memory" (a rota de proxy do OE, que remove /memory/ antes de encaminhar para o servidor de memória). Use "/api/v1" ao se conectar diretamente ao servidor de memória.

dynamicHeaders?

() => Record <string, string>

undefined

Chamado a cada pedido; o resultado é mesclado em staticHeaders. Usado pelo Agent-Engine- Runner-Shared para injetar X-Agent-Engine-Execution-Id com escopo de execução do AsyncLocalStorage.

requestExtras?

() => RequestInit | undefined

undefined

Chamado a cada pedido; o RequestInit retornado é distribuído em fetch init antes do método/headers/signal. Usado para injetar um transporte personalizado (por exemplo, um undici mTLS dispatcher) para chamadas vinculadas ao aplicativo.

maxRetries?

number

0

Número de tentativas em 5xx transitórios (502/503/504) e erros de rede, com backoff exponencial. 0 padrão (sem novas tentativas).

routeStyle?

`MemoryRouteStyle <#memoryroutetype>`__

"native"

convenção de rota de memória (consulte MemoryRouteStyle). O padrão é "nativo" - as rotas de proxy do servidor de memória / OE. Use "aliased" para as rotas com escopo de projeto do API Gateway (/turns, /context, único /search com um campo de corpo type ).

fetchImpl?

{ (input, init?): Promise <Response>; (input, init?): Promise <Response>; }

undefined

Devoluções

`MemoryClient <#memoryclient>`__

Métodos

bootstrap()
bootstrap(): void;

Devoluções

void

buildContext()
buildContext(params): Promise<{
[key: string]: unknown;
  formatted_context: string | Record<string, unknown>[];
  metadata: {
   [key: string]: unknown;
     memory_counts: Record<string, number>;
     timing: Record<string, number>;
     token_count: number;
  };
  selected_memories?: object[] | null;
}>;

Crie um contexto de memória unificado. enabledSources omitido tem como padrão omitido e semântica; inclua "stm" para voltas recentes.

Parâmetros

Parâmetro
Tipo
Descrição

params

{ enabledSources?: string [] | null; formatStyle?: string | null; maxTokens?: number; metadataFilter?: Record <string, unknown> | null; orgId: string; projectId: string; query: string; sessionId?: string | null; signal?: AbortSignal; topK?: number; userId?: string | null; visibility?: string | null; }

params.enabledSources?

string [] | null

params.formatStyle?

string | null

params.maxTokens?

number

orçamento bruto opcional para construção de contexto, serializado como max_tokens somente quando definido. Após a recuperação e a classificação, o servidor subtrai uma reserva de formatação de 500-token e, em seguida, seleciona avidamente chunks de memória inteiros que cabem no restante. Valores positivos iguais ou inferiores a 500 não deixam orçamento para recordações. Valores acima de 500 ainda podem gerar um contexto vazio quando nenhum chunk se encaixa. Valores não positivos, não inteiros e não finitos aumentam antes de a solicitação ser enviada.

params.metadataFilter?

Record <string, unknown> | null

params.orgId

string

params.projectId

string

params.query

string

params.sessionId?

string | null

params.signal?

AbortSignal

params.topK?

number

params.userId?

string | null

params.visibility?

string | null

Devoluções

Promise <{ [key: string]: unknown; formatted_context: string | Record <string, unknown>[]; metadata: { [key: string]: unknown; memory_counts: Record <string, number>; timing: Record <string, number>; token_count: number; }; selected_memories?: object [] | null; }>

createCustom()
createCustom(params): Promise<{
  has_embedding: boolean;
  id: string;
  tags: Record<string, string | number | boolean>;
  type: string;
}>;

Parâmetros

Parâmetro
Tipo

params

{ content: string; contextualMetadata?: Record <string, unknown> | null; memoryType: string; signal?: AbortSignal; tags?: Record <string, unknown> | null; }

params.content

string

params.contextualMetadata?

Record <string, unknown> | null

params.memoryType

string

params.signal?

AbortSignal

params.tags?

Record <string, unknown> | null

Devoluções

Promise <{ has_embedding: boolean; id: string; tags: Record <string, string | number | boolean>; type: string; }>

createEpisodic()
createEpisodic(params): Promise<{
[key: string]: unknown;
  acknowledged: boolean;
  has_embedding: boolean;
  id: string;
  title: string;
}>;

Parâmetros

Parâmetro
Tipo

params

{ agentId?: string | null; content: string; embedding?: number [] | null; extractionSource?: string | null; metadata?: Record <string, unknown> | null; orgId: string; participants?: string [] | null; projectId: string; sessionId: string; signal?: AbortSignal; skipEmbedding?: boolean | null; snapshotRefId?: string | null; sourceAgent?: string | null; summaryText: string; summaryType?: string | null; tags?: string [] | null; title: string; userId: string; visibility?: string; }

params.agentId?

string | null

params.content

string

params.embedding?

number [] | null

params.extractionSource?

string | null

params.metadata?

Record <string, unknown> | null

params.orgId

string

params.participants?

string [] | null

params.projectId

string

params.sessionId

string

params.signal?

AbortSignal

params.skipEmbedding?

boolean | null

params.snapshotRefId?

string | null

params.sourceAgent?

string | null

params.summaryText

string

params.summaryType?

string | null

params.tags?

string [] | null

params.title

string

params.userId

string

params.visibility?

string

Devoluções

Promise <{ [key: string]: unknown; acknowledged: boolean; has_embedding: boolean; id: string; title: string; }>

createProcedural()
createProcedural(params): Promise<{
[key: string]: unknown;
  acknowledged: boolean;
  has_embedding: boolean;
  id: string;
  procedure: string;
}>;

Parâmetros

Parâmetro
Tipo

params

{ agentId?: string | null; allowedTools?: string [] | null; compatibility?: string | null; content: string; description: string; extractionSource?: string | null; license?: string | null; orgId: string; procedure: string; projectId: string; resources?: Record <string, unknown>[] | null; signal?: AbortSignal; sourceFormat?: string | null; sourcePath?: string | null; steps?: Record <string, unknown>[] | null; tags?: string [] | null; triggerConditions?: string [] | null; userId: string; visibility?: string; }

params.agentId?

string | null

params.allowedTools?

string [] | null

params.compatibility?

string | null

params.content

string

params.description

string

params.extractionSource?

string | null

params.license?

string | null

params.orgId

string

params.procedure

string

params.projectId

string

params.resources?

Record <string, unknown>[] | null

params.signal?

AbortSignal

params.sourceFormat?

string | null

params.sourcePath?

string | null

params.steps?

Record <string, unknown>[] | null

params.tags?

string [] | null

params.triggerConditions?

string [] | null

params.userId

string

params.visibility?

string

Devoluções

Promise <{ [key: string]: unknown; acknowledged: boolean; has_embedding: boolean; id: string; procedure: string; }>

createSemantic()
createSemantic(params): Promise<{
[key: string]: unknown;
  acknowledged: boolean;
  has_embedding: boolean;
  id: string;
  label: string;
}>;

Parâmetros

Parâmetro
Tipo

params

{ agentId?: string | null; embedding?: number [] | null; label: string; metadata?: Record <string, unknown> | null; orgId: string; projectId: string; signal?: AbortSignal; source?: string; text: string; upsert?: boolean; userId: string; visibility?: string; }

params.agentId?

string | null

params.embedding?

number [] | null

params.label

string

params.metadata?

Record <string, unknown> | null

params.orgId

string

params.projectId

string

params.signal?

AbortSignal

params.source?

string

params.text

string

params.upsert?

boolean

params.userId

string

params.visibility?

string

Devoluções

Promise <{ [key: string]: unknown; acknowledged: boolean; has_embedding: boolean; id: string; label: string; }>

createTaxonomic()
createTaxonomic(params): Promise<{
[key: string]: unknown;
  acknowledged: boolean;
  domain: string;
  has_embedding: boolean;
  id: string;
  term: string;
}>;

Parâmetros

Parâmetro
Tipo

params

{ definition: string; domain: string; orgId: string; projectId: string; queryExpansion?: boolean; relatedTerms?: string [] | null; signal?: AbortSignal; term: string; userId: string; visibility?: string; }

params.definition

string

params.domain

string

params.orgId

string

params.projectId

string

params.queryExpansion?

boolean

params.relatedTerms?

string [] | null

params.signal?

AbortSignal

params.term

string

params.userId

string

params.visibility?

string

Devoluções

Promise <{ [key: string]: unknown; acknowledged: boolean; domain: string; has_embedding: boolean; id: string; term: string; }>

deleteProcedural()
deleteProcedural(params): Promise<{
[key: string]: unknown;
  acknowledged: boolean;
  deleted_count: number;
}>;

Parâmetros

Parâmetro
Tipo

params

{ id?: string | null; orgId: string; procedure?: string | null; projectId: string; signal?: AbortSignal; soft?: boolean; }

params.id?

string | null

params.orgId

string

params.procedure?

string | null

params.projectId

string

params.signal?

AbortSignal

params.soft?

boolean

Devoluções

Promise <{ [key: string]: unknown; acknowledged: boolean; deleted_count: number; }>

findProceduras()
discoverProcedures(params): Promise<Record<string, unknown>[]>;

Parâmetros

Parâmetro
Tipo

params

{ metadataFilter?: Record <string, unknown> | null; orgId: string; projectId: string; query: string; signal?: AbortSignal; similarityThreshold?: number; tags?: string [] | null; topK?: number; userId?: string | null; visibility?: string | null; }

params.metadataFilter?

Record <string, unknown> | null

params.orgId

string

params.projectId

string

params.query

string

params.signal?

AbortSignal

params.similarityThreshold?

number

params.tags?

string [] | null

params.topK?

number

params.userId?

string | null

params.visibility?

string | null

Devoluções

Promise <Record <string, unknown>[]>

fetchEpisodicMemories()
fetchEpisodicMemories(params): Promise<object[]>;

Parâmetros

Parâmetro
Tipo

params

{ orgId: string; projectId: string; query: string; sessionId?: string | null; signal?: AbortSignal; topK?: number; userId?: string | null; visibility?: string | null; }

params.orgId

string

params.projectId

string

params.query

string

params.sessionId?

string | null

params.signal?

AbortSignal

params.topK?

number

params.userId?

string | null

params.visibility?

string | null

Devoluções

Promise <object []>

fetchProceduralMemories()
fetchProceduralMemories(params): Promise<object[]>;

Parâmetros

Parâmetro
Tipo

params

{ orgId: string; projectId: string; query: string; signal?: AbortSignal; tags?: string [] | null; topK?: number; userId?: string | null; visibility?: string | null; }

params.orgId

string

params.projectId

string

params.query

string

params.signal?

AbortSignal

params.tags?

string [] | null

params.topK?

number

params.userId?

string | null

params.visibility?

string | null

Devoluções

Promise <object []>

fetchSemanticMemories()
fetchSemanticMemories(params): Promise<object[]>;

Parâmetros

Parâmetro
Tipo

params

{ orgId: string; projectId: string; query: string; signal?: AbortSignal; topK?: number; userId?: string | null; visibility?: string | null; }

params.orgId

string

params.projectId

string

params.query

string

params.signal?

AbortSignal

params.topK?

number

params.userId?

string | null

params.visibility?

string | null

Devoluções

Promise <object []>

fetchTaxonomicMemories()
fetchTaxonomicMemories(params): Promise<object[]>;

Parâmetros

Parâmetro
Tipo

params

{ domain?: string | null; orgId: string; projectId: string; query: string; signal?: AbortSignal; topK?: number; userId?: string | null; visibility?: string | null; }

params.domain?

string | null

params.orgId

string

params.projectId

string

params.query

string

params.signal?

AbortSignal

params.topK?

number

params.userId?

string | null

params.visibility?

string | null

Devoluções

Promise <object []>

getDistinctDomains()
getDistinctDomains(params): Promise<string[]>;

Parâmetros

Parâmetro
Tipo

params

{ orgId: string; projectId: string; signal?: AbortSignal; visibility?: string | null; }

params.orgId

string

params.projectId

string

params.signal?

AbortSignal

params.visibility?

string | null

Devoluções

Promise <string []>

getProcedural()
getProcedural(params): Promise<unknown>;

Parâmetros

Parâmetro
Tipo

params

{ id?: string | null; includeDeleted?: boolean; orgId: string; procedure?: string | null; projectId: string; signal?: AbortSignal; userId?: string | null; visibility?: string | null; }

params.id?

string | null

params.includeDeleted?

boolean

params.orgId

string

params.procedure?

string | null

params.projectId

string

params.signal?

AbortSignal

params.userId?

string | null

params.visibility?

string | null

Devoluções

Promise <unknown>

getSemantic()
getSemantic(params): Promise<unknown>;

Parâmetros

Parâmetro
Tipo

params

{ id?: string | null; label?: string | null; orgId: string; projectId: string; signal?: AbortSignal; userId?: string | null; visibility?: string | null; }

params.id?

string | null

params.label?

string | null

params.orgId

string

params.projectId

string

params.signal?

AbortSignal

params.userId?

string | null

params.visibility?

string | null

Devoluções

Promise <unknown>

getTaxonomic()
getTaxonomic(params): Promise<unknown>;

Parâmetros

Parâmetro
Tipo

params

{ domain?: string | null; orgId: string; projectId: string; signal?: AbortSignal; term?: string | null; userId?: string | null; visibility?: string | null; }

params.domain?

string | null

params.orgId

string

params.projectId

string

params.signal?

AbortSignal

params.term?

string | null

params.userId?

string | null

params.visibility?

string | null

Devoluções

Promise <unknown>

listEpisodic()
listEpisodic(params): Promise<unknown[]>;

Parâmetros

Parâmetro
Tipo

params

{ limit?: number; orgId: string; projectId: string; sessionId?: string | null; signal?: AbortSignal; userId?: string | null; visibility?: string | null; }

params.limit?

number

params.orgId

string

params.projectId

string

params.sessionId?

string | null

params.signal?

AbortSignal

params.userId?

string | null

params.visibility?

string | null

Devoluções

Promise <unknown []>

retrieveCustom()
retrieveCustom(params): Promise<{
  count: number;
  results: object[];
}>;

Parâmetros

Parâmetro
Tipo

params

{ memoryType: string; query: string; signal?: AbortSignal; tags?: Record <string, unknown> | null; topK?: number; }

params.memoryType

string

params.query

string

params.signal?

AbortSignal

params.tags?

Record <string, unknown> | null

params.topK?

number

Devoluções

Promise <{ count: number; results: object []; }>

atualizarProcedural()
updateProcedural(params): Promise<unknown>;

Parâmetros

Parâmetro
Tipo

params

{ allowedTools?: string [] | null; content?: string | null; description?: string | null; id?: string | null; orgId: string; procedure?: string | null; projectId: string; resources?: Record <string, unknown>[] | null; signal?: AbortSignal; steps?: Record <string, unknown>[] | null; tags?: string [] | null; triggerConditions?: string [] | null; visibility?: string | null; }

params.allowedTools?

string [] | null

params.content?

string | null

params.description?

string | null

params.id?

string | null

params.orgId

string

params.procedure?

string | null

params.projectId

string

params.resources?

Record <string, unknown>[] | null

params.signal?

AbortSignal

params.steps?

Record <string, unknown>[] | null

params.tags?

string [] | null

params.triggerConditions?

string [] | null

params.visibility?

string | null

Devoluções

Promise <unknown>

updateSemantic()
updateSemantic(params): Promise<unknown>;

Parâmetros

Parâmetro
Tipo

params

{ label: string; orgId: string; projectId: string; signal?: AbortSignal; source?: string | null; text?: string | null; visibility?: string | null; }

params.label

string

params.orgId

string

params.projectId

string

params.signal?

AbortSignal

params.source?

string | null

params.text?

string | null

params.visibility?

string | null

Devoluções

Promise <unknown>

writeTurn()
writeTurn(params): Promise<{
[key: string]: unknown;
  acknowledged: boolean;
  id: string;
  session_id: string;
  turn_seq: number;
}>;

Parâmetros

Parâmetro
Tipo

params

{ content?: string | null; idempotencyKey?: string | null; isError?: boolean; modelName?: string | null; orgId: string; projectId: string; role: string; sessionId?: string | null; signal?: AbortSignal; stopReason?: string | null; tokens?: number | null; toolCallId?: string | null; toolCalls?: Record <string, unknown>[] | null; toolName?: string | null; userId?: string | null; }

params.content?

string | null

params.idempotencyKey?

string | null

params.isError?

boolean

params.modelName?

string | null

params.orgId

string

params.projectId

string

params.role

string

params.sessionId?

string | null

params.signal?

AbortSignal

params.stopReason?

string | null

params.tokens?

number | null

params.toolCallId?

string | null

params.toolCalls?

Record <string, unknown>[] | null

params.toolName?

string | null

params.userId?

string | null

Devoluções

Promise <{ [key: string]: unknown; acknowledged: boolean; id: string; session_id: string; turn_seq: number; }>

MemoryHttpError

Lançado para respostas do servidor de memória não OK. Carrega o status e o corpo do HTTP para que os chamadores possam ramificar no modo de falha (por exemplo, mapear 401/403/404/5xx para erros digitados) em vez de analisar uma string de mensagem. Estende Error, de modo que os consumidores catch (e) { ... } existentes não são afetados.

Estende-se

  • Error

Constructor

new MemoryHttpError(status, responseText): MemoryHttpError;

Parâmetros

Parâmetro
Tipo

status

number

responseText

string

Devoluções

`MemoryHttpError <#memoryhttperror>`__

Substitui

Error.constructor

Propriedades

Propriedade
Modifier
Tipo

responseText

readonly

string

status

readonly

number

NullExecutionCallback

classe de base concreta com padrões no-op para todos os métodos BaseExecutionCallback.

Subclassifique isso em vez de implementar BaseExecutionCallback diretamente para que os novos métodos adicionados à interface sejam automaticamente satisfeitos — você só substitui os eventos dos quais se importa.

class MyCallback extends NullExecutionCallback {
  onNodeStart(nodeName: string, _inputs, _opts) {
    console.log(`starting ${nodeName}`)
  }
}

Implementos

  • `BaseExecutionCallback <#baseexecutioncallback>`__

Constructor

new NullExecutionCallback(): NullExecutionCallback;

Devoluções

`NullExecutionCallback <#nullexecutioncallback>`__

Métodos

onNodeEnd()
onNodeEnd(
   _nodeName,
   _outputs,
   _opts
): void;

Parâmetros

Parâmetro
Tipo

_nodeName

string

_outputs

Record <string, unknown>

_opts

{ durationMs?: number; metadata?: Record <string, unknown>; parentRunId?: string; runId: string; }

_opts.durationMs?

number

_opts.metadata?

Record <string, unknown>

_opts.parentRunId?

string

_opts.runId

string

Devoluções

void

Implementação de

`BaseExecutionCallback <#baseexecutioncallback>`__. `onNodeEnd <#onnodeend-1>`__

onNodeError()
onNodeError(
   _nodeName,
   _error,
   _opts
): void;

Parâmetros

Parâmetro
Tipo

_nodeName

string

_error

string

_opts

{ metadata?: Record <string, unknown>; parentRunId?: string; runId: string; }

_opts.metadata?

Record <string, unknown>

_opts.parentRunId?

string

_opts.runId

string

Devoluções

void

Implementação de

`BaseExecutionCallback <#baseexecutioncallback>`__. `onNodeError <#onnodeerror-1>`__

onNodeStart()
onNodeStart(
   _nodeName,
   _inputs,
   _opts
): void;

Parâmetros

Parâmetro
Tipo

_nodeName

string

_inputs

Record <string, unknown>

_opts

{ metadata?: Record <string, unknown>; parentRunId?: string; runId: string; }

_opts.metadata?

Record <string, unknown>

_opts.parentRunId?

string

_opts.runId

string

Devoluções

void

Implementação de

`BaseExecutionCallback <#baseexecutioncallback>`__. `onNodeStart <#onnodestart-1>`__

onNodeSuspend()
onNodeSuspend(_nodeName, _opts): void;

Parâmetros

Parâmetro
Tipo

_nodeName

string

_opts

{ metadata?: Record <string, unknown>; parentRunId?: string; runId: string; }

_opts.metadata?

Record <string, unknown>

_opts.parentRunId?

string

_opts.runId

string

Devoluções

void

Interfaces

AgentInput

Entrada para a execução de um agente . A carga útil é um valor JSON opaco.

Propriedades

Propriedade
Tipo

payload

`JsonValue <#jsonvalue>`__

AgentOutput

Saída de uma execução do agente . A resposta é um valor JSON opaco.

Propriedades

Propriedade
Tipo

response

`JsonValue <#jsonvalue>`__

Agente de base

O contrato entre o código do agente e os tempos de execução.

Os agentes expõem um único método execute() que retorna um ExecutionResult. Os chamadores escolhem o modo de execução : - await agent.execute(ctx, input) para um resultado final ( estilo JSON ) - for await (const event of agent.execute(ctx, input)) para transmissão ( estilo SSE )

Métodos

execute()
execute(ctx, input): ExecutionResult;

Parâmetros

Parâmetro
Tipo

ctx

`RequestContext <#requestcontext>'__

input

`AgentInput <#agentinput>`__

Devoluções

`ExecutionResult <#executionresult>`__

BaseExecutionCallback

chamada de resposta independente da estrutura para observabilidade durante a execução do agente .

Substitui BaseCallbackHandler da LangChain. O AER injeta uma implementação que encaminha eventos de nó para o OE para registro. Adaptadores de estrutura (por exemplo, sdk-langgraph) fazem a ponte do sistema de chamada de resposta nativo da estrutura para essa interface.

Prefira subclassificar NullExecutionCallback em vez de implementar essa interface diretamente – ela fornece padrões sem operação para todos os métodos, incluindo extensões opcionais (por exemplo, onNodeSuspend) para que os novos métodos nunca quebrem as implementações existentes.

Métodos

onNodeEnd()
onNodeEnd(
   nodeName,
   outputs,
   opts
): void;

Parâmetros

Parâmetro
Tipo

nodeName

string

outputs

Record <string, unknown>

opts

{ durationMs?: number; metadata?: Record <string, unknown>; parentRunId?: string; runId: string; }

opts.durationMs?

number

opts.metadata?

Record <string, unknown>

opts.parentRunId?

string

opts.runId

string

Devoluções

void

onNodeError()
onNodeError(
   nodeName,
   error,
   opts
): void;

Parâmetros

Parâmetro
Tipo

nodeName

string

error

string

opts

{ metadata?: Record <string, unknown>; parentRunId?: string; runId: string; }

opts.metadata?

Record <string, unknown>

opts.parentRunId?

string

opts.runId

string

Devoluções

void

onNodeStart()
onNodeStart(
   nodeName,
   inputs,
   opts
): void;

Parâmetros

Parâmetro
Tipo

nodeName

string

inputs

Record <string, unknown>

opts

{ metadata?: Record <string, unknown>; parentRunId?: string; runId: string; }

opts.metadata?

Record <string, unknown>

opts.parentRunId?

string

opts.runId

string

Devoluções

void

BaseLLM

Protocolo LLM neutro em termos de framework.

Usado no tempo de execução pelo ToolPod. No Python, esse protocolo expõe invoke (síncrono) e ainvoke (assíncrono), pois o Python oferece suporte a ambos os estilos de chamada. JS não tem HTTP de sincronização, então essa interface tem um único invoke assíncrono mais stream.

Métodos

invoke()
invoke(messages, kwargs?): Promise<LLMResponse>;

Parâmetros

Parâmetro
Tipo

messages

`Message <#message>`__ []

kwargs?

Record <string, unknown>

Devoluções

Promise <`LLMResponse <#llmresponse>`__>

stream()
stream(messages, kwargs?): AsyncIterable<LLMStreamChunk>;

Parâmetros

Parâmetro
Tipo

messages

`Message <#message>`__ []

kwargs?

Record <string, unknown>

Devoluções

AsyncIterable <`LLMStreamChunk <#llmstreamchunk>`__>

ExecutionResult

Resultado da execução de um agente .

Aguarde o resultado final ou itere assíncrono para eventos de streaming.

// Non-streaming
const output = await agent.execute(ctx, input)
// Streaming
for await (const event of agent.execute(ctx, input)) {
  handle(event)
}

Estende-se

  • PromiseLike <`AgentOutput <#agentoutput>`__>. AsyncIterable <`StreamEvent <#streamevent>`__>

LLMStreamChunk

Pedaço de streaming avançado seguindo padrões OpenAI/Antrópicos.

Todos os campos são opcionais, pois chunks diferentes contêm dados diferentes: - chunks de conteúdo: deltas de texto durante a geração - chunks de chamada de ferramenta: chamadas parciais de ferramentas sendo construídas - chunks de uso: contagens de token no final do fluxo

Propriedades

Propriedade
Tipo

additionalKwargs?

Record <string, `JsonValue <#jsonvalue>`__>

content?

string

id?

string

name?

string

responseMetadata?

Record <string, `JsonValue <#jsonvalue>`__>

toolCalls?

`ToolCallChunk <#toolcallchunk>`__ []

usage?

`LLMTokenUsage <#llmtokenusage>`__

mensagem

Mensagem neutro em relação à estrutura.

O conteúdo pode ser uma string simples para mensagens somente de texto ou uma lista de blocos de conteúdo para conteúdo multimodal (imagens, documentos etc.).

Propriedades

Propriedade
Tipo

additionalKwargs?

Record <string, `JsonValue <#jsonvalue>`__>

content

| string | ( | { text: string; type: "text"; } | { mime_type?: string; type: "image"; url: string; } | { filename?: string; mime_type?: string; type: "document"; url: string; })[]

id?

string

isError?

boolean

name?

string

responseMetadata?

Record <string, `JsonValue <#jsonvalue>`__>

role

`Role <#role>`__

toolCallId?

string

toolCalls?

`LLMToolCall <#llmtoolcall>`__ []

RequestContext

Contexto do escopo da solicitação passado para cada execução do agente .

Carrega a identidade de execução independente da framework e a sondagem da plataforma. A entrada de invocação do chamador reside em AgentInput.payload, não aqui. O estado Suspender/retomar é ocultado da plataforma: metadata é um blob de propriedade da estrutura que a plataforma encaminha inalterado na retomada.

Propriedades

Propriedade
Tipo
Descrição

executionId?

string

metadata?

Record <string, `JsonValue <#jsonvalue>`__> | null

Estado de propriedade da estrutura opaca passado pelo SDK e AER. Somente o adaptador de estrutura selecionado pode interpretar suas chaves e valores.

previousExecutionCancelled?

boolean

Verdadeiro quando a execução anterior mais recente desta sessão foi cancelada (seu pod dividido no meio da execução). Os adaptadores de framework que persistem no estado por etapa o usam para isolar as gravações parciais da etapa eliminada antes de executar esse estágio. Simula o previous_execution_cancelled do Python.

requestHeaders?

Record <string, string>

resume?

boolean

A plataforma suspende/retoma o encanamento (estrutura-neutra).

resumeData?

`JsonValue <#jsonvalue>`__

sessionId?

string

signal?

AbortSignal

Sinal de cancelamento para tempo limite de execução ou cancelamento forçado. O tempo de execução (e qualquer implementação de agente que o vincule) deve desenrolar as esperas pendentes e parar de emitir eventos quando esse sinal for acionado. Python depende de asyncio.wait_for para a mesma semântica; JS não tem cancelamento implícito, portanto, o sinal deve ser sondado explicitamente.

userId?

string

workspaceId?

string

Escopo do inquilino do agente de execução. Os adaptadores de framework o usam para definir o escopo de armazenamentos de estados digitados somente por sessionId (por exemplo, o thread_id de checkpoint do LangGraph), para que os agentes no mesmo banco de dados do projeto não possam colidir. Mirror RequestContext.workspace_id do Python.

StreamEvent

Evento transmitido de volta para o chamador durante a execução.

Propriedades

Propriedade
Tipo

data

`JsonValue <#jsonvalue>`__

event?

string

ToolCallChunk

Chamada de ferramenta parcial durante a transmissão.

Todos os campos são opcionais, pois os chunks podem conter dados parciais (por exemplo, apenas o início dos argumentos ou apenas o nome da ferramenta).

Propriedades

Propriedade
Tipo

args?

string

id?

string

index?

number

name?

string

type?

string

Aliases de tipo

AnyContentBlock

type AnyContentBlock = z.infer<typeof AnyContentBlockSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

Referência de ramificação

type BranchRef = z.infer<typeof BranchRefSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

BulkCreateSemanticResult

type BulkCreateSemanticResult = z.infer<typeof BulkCreateSemanticResultSchema>;

ContextConfig

type ContextConfig = z.infer<typeof ContextConfigSchema>;

ContextMetadata

type ContextMetadata = z.infer<typeof ContextMetadataSchema>;

Resposta do contexto

type ContextResponse = z.infer<typeof ContextResponseSchema>;

CreateEpisodicResult

type CreateEpisodicResult = z.infer<typeof CreateEpisodicResultSchema>;

CreateProceduralResult

type CreateProceduralResult = z.infer<typeof CreateProceduralResultSchema>;

CreateSemanticResult

type CreateSemanticResult = z.infer<typeof CreateSemanticResultSchema>;

CreateSnapshotResult

type CreateSnapshotResult = z.infer<typeof CreateSnapshotResultSchema>;

CreateTaxonomicResult

type CreateTaxonomicResult = z.infer<typeof CreateTaxonomicResultSchema>;

CreateUserContextResult

type CreateUserContextResult = z.infer<typeof CreateUserContextResultSchema>;

CustomMemoryRetrieveResult

type CustomMemoryRetrieveResult = z.infer<typeof CustomMemoryRetrieveResultSchema>;

CustomMemorySaveResult

type CustomMemorySaveResult = z.infer<typeof CustomMemorySaveResultSchema>;

DeleteResult

type DeleteResult = z.infer<typeof DeleteResultSchema>;

Bloqueio de documentos

type DocumentBlock = z.infer<typeof DocumentBlockSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

Evento

type Event = z.infer<typeof EventSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

Resposta do evento

type EventResponse = z.infer<typeof EventResponseSchema>;

Resposta dos eventos

type EventsResponse = z.infer<typeof EventsResponseSchema>;

FormatStyle

type FormatStyle = z.infer<typeof FormatStyleSchema>;

Bloqueio de imagem

type ImageBlock = z.infer<typeof ImageBlockSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

InternalStateResult

type InternalStateResult = z.infer<typeof InternalStateResultSchema>;

ISGenerationResult

type ISGenerationResult = z.infer<typeof ISGenerationResultSchema>;

JsonValue

type JsonValue =
  | string
  | number
  | boolean
  | null
  | JsonValue[]
  | {
[key: string]: JsonValue;
};

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

MemoryChunk

type MemoryChunk = z.infer<typeof MemoryChunkSchema>;

MemoryRouteStyle

type MemoryRouteStyle = "native" | "aliased";

Qual convenção de rota de memória um backend fala.

  • native: as rotas do próprio servidor de memória (/stm/turns, /retrieval/*). Distribuído diretamente pelo servidor de memória e pelo proxy OE (que também aceita os formulários com nomes alternativos). Esse é o padrão e preserva o comportamento de todos os consumidores existentes.

  • aliased: as rotas de memória com escopo de projeto do API Gateway, em que o loop principal se recolhe para /turns, /context e um único /search que seleciona a origem por meio de um campo de corpo type . O Gateway não expõe os caminhos nativos /stm ou /retrieval, portanto, um cliente direto do Gateway deve usar isso.

Fonte de memória

type MemorySource = z.infer<typeof MemorySourceSchema>;

ModelType

type ModelType = z.infer<typeof ModelTypeSchema>;

PromoverSnapshotResult

type PromoteSnapshotResult = z.infer<typeof PromoteSnapshotResultSchema>;

RetrievedCustomMemory

type RetrievedCustomMemory = z.infer<typeof RetrievedCustomMemorySchema>;

Função

type Role = "user" | "assistant" | "tool" | "system";

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

Mensagem da sessão

type SessionMessage = z.infer<typeof SessionMessageSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

SessionMessagesResponse

type SessionMessagesResponse = z.infer<typeof SessionMessagesResponseSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

SessionsSummaryResponse

type SessionsSummaryResponse = z.infer<typeof SessionsSummaryResponseSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

SessionSummary

type SessionSummary = z.infer<typeof SessionSummarySchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

TagScalar

type TagScalar = z.infer<typeof TagScalarSchema>;

TextBlock

type TextBlock = z.infer<typeof TextBlockSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

Definição de ferramenta

type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

Entrada de definição de ferramenta

type ToolDefinitionInput = z.input<typeof ToolDefinitionSchema>;

@mongodb-js/agent-engine-sdk — Protocolos e modelos do Core TypeScript para o MongoDB Agent Engine.

WriteTurnResult

type WriteTurnResult = z.infer<typeof WriteTurnResultSchema>;

variáveis

AgentInputSchema

const AgentInputSchema: ZodObject<{
  payload: ZodUnknown & ZodType<
     | {
   }
     | null, unknown, $ZodTypeInternals<
     | {
   }
    | null, unknown>>;
}, $loose>;

Esquema de validação de tempo de execução para dados de fio do AgentInput.

AgentOutputSchema

const AgentOutputSchema: ZodObject<{
  response: ZodUnknown & ZodType<
     | {
   }
     | null, unknown, $ZodTypeInternals<
     | {
   }
    | null, unknown>>;
}, $loose>;

Esquema de validação de tempo de execução para dados de conexão AgentOutput.

AnyContentBlockSchema

const AnyContentBlockSchema: ZodDiscriminatedUnion<[ZodObject<{
  text: ZodString;
  type: ZodDefault<ZodLiteral<"text">>;
}, $strip>, ZodObject<{
  mime_type: ZodOptional<ZodString>;
  type: ZodDefault<ZodLiteral<"image">>;
  url: ZodString;
}, $strip>, ZodObject<{
  filename: ZodOptional<ZodString>;
  mime_type: ZodOptional<ZodString>;
  type: ZodDefault<ZodLiteral<"document">>;
  url: ZodString;
}, $strip>], "type">;

Discriminado em type para que um bloco de documento nunca seja analisado incorretamente como uma imagem (uma união simples combinaria { url } com ImageBlockSchema primeiro e descartaria silenciosamente filename). As entradas devem carregar um type explícito.

BranchRefSchema

const BranchRefSchema: ZodObject<{
  name: ZodString;
  root_event_id: ZodString;
}, $loose>;

Referência a uma ramificação e seu ponto de bifurcação .

BulkCreateSemanticResultSchema

const BulkCreateSemanticResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  created_count: ZodNumber;
  created_ids: ZodArray<ZodString>;
  has_embeddings: ZodBoolean;
  skipped_count: ZodNumber;
  skipped_labels: ZodArray<ZodString>;
}, $loose>;

ContextConfigSchema

const ContextConfigSchema: ZodObject<{
  enabled_sources: ZodDefault<ZodPipe<ZodArray<ZodEnum<{
     episodic: "episodic";
     procedural: "procedural";
     semantic: "semantic";
     stm: "stm";
     taxonomic: "taxonomic";
  }>>, ZodTransform<("stm" | "episodic" | "semantic" | "taxonomic" | "procedural")[], ("stm" | "episodic" | "semantic" | "taxonomic" | "procedural")[]>>>;
  format_style: ZodDefault<ZodPreprocess<ZodEnum<{
     claude: "claude";
     jinja2: "jinja2";
     openai: "openai";
  }>>>;
  include_memories: ZodDefault<ZodBoolean>;
  max_tokens: ZodDefault<ZodNumber>;
  model_type: ZodDefault<ZodPreprocess<ZodEnum<{
     anthropic: "anthropic";
     claude: "claude";
     gemini: "gemini";
     generic: "generic";
     openai: "openai";
  }>>>;
  ranking_weights: ZodDefault<ZodRecord<ZodString, ZodNumber>>;
  similarity_threshold: ZodDefault<ZodNumber>;
  token_buffer: ZodDefault<ZodNumber>;
}, $strip>;

Configuração para solicitações de construção de contexto.

ContextMetadataSchema

const ContextMetadataSchema: ZodObject<{
  memory_counts: ZodDefault<ZodRecord<ZodString, ZodNumber>>;
  timing: ZodDefault<ZodRecord<ZodString, ZodNumber>>;
  token_count: ZodDefault<ZodNumber>;
}, $loose>;

Metadados sobre uma resposta de compilação de contexto (contagens de token, contagens por fonte, tempo).

ContextResponseSchema

const ContextResponseSchema: ZodObject<{
  formatted_context: ZodUnion<readonly [ZodString, ZodArray<ZodRecord<ZodString, ZodUnknown>>]>;
  metadata: ZodObject<{
     memory_counts: ZodDefault<ZodRecord<ZodString, ZodNumber>>;
     timing: ZodDefault<ZodRecord<ZodString, ZodNumber>>;
     token_count: ZodDefault<ZodNumber>;
  }, $loose>;
  selected_memories: ZodOptional<ZodNullable<ZodArray<ZodObject<{
     content: ZodString;
     embedding: ZodOptional<ZodArray<ZodNumber>>;
     id: ZodString;
     metadata: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
     similarity_score: ZodOptional<ZodNumber>;
     source: ZodEnum<{
        episodic: "episodic";
        procedural: "procedural";
        semantic: "semantic";
        stm: "stm";
        taxonomic: "taxonomic";
     }>;
     timestamp: ZodPipe<ZodString, ZodTransform<Date, string>>;
  }, $loose>>>>;
}, $loose>;

Resposta de uma solicitação de construção de contexto contendo contexto formatado e metadados de recuperação.

CreateEpisodicResultSchema

const CreateEpisodicResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  has_embedding: ZodBoolean;
  id: ZodString;
  title: ZodString;
}, $loose>;

CreateProceduralResultSchema

const CreateProceduralResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  has_embedding: ZodBoolean;
  id: ZodString;
  procedure: ZodString;
}, $loose>;

CreateSemanticResultSchema

const CreateSemanticResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  has_embedding: ZodBoolean;
  id: ZodString;
  label: ZodString;
}, $loose>;

CreateSnapshotResultSchema

const CreateSnapshotResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  embedding_strategy: ZodOptional<ZodString>;
  has_embedding: ZodBoolean;
  id: ZodString;
  message_count: ZodNumber;
  session_id: ZodString;
  snapshot_reason: ZodString;
}, $loose>;

CreateTaxonomicResultSchema

const CreateTaxonomicResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  domain: ZodString;
  has_embedding: ZodBoolean;
  id: ZodString;
  term: ZodString;
}, $loose>;

CreateUserContextResultSchema

const CreateUserContextResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  context_key: ZodString;
  id: ZodString;
}, $loose>;

CustomMemoryRetrieveResultSchema

const CustomMemoryRetrieveResultSchema: ZodObject<{
  count: ZodNumber;
  results: ZodArray<ZodObject<{
     agent_id: ZodOptional<ZodNullable<ZodString>>;
     content: ZodString;
     contextual_metadata: ZodOptional<ZodNullable<ZodRecord<ZodString, ZodUnknown>>>;
     id: ZodString;
     tags: ZodRecord<ZodString, ZodUnion<readonly [ZodString, ZodNumber, ZodBoolean]>>;
     type: ZodString;
     user_id: ZodOptional<ZodNullable<ZodString>>;
  }, $strip>>;
}, $strip>;

CustomMemorySaveResultSchema

const CustomMemorySaveResultSchema: ZodObject<{
  has_embedding: ZodBoolean;
  id: ZodString;
  tags: ZodRecord<ZodString, ZodUnion<readonly [ZodString, ZodNumber, ZodBoolean]>>;
  type: ZodString;
}, $strip>;

DateFromStringSchema

const DateFromStringSchema: ZodPipe<ZodString, ZodTransform<Date, string>>;

Analisa uma string de data/hora ISO em uma Data. Rejeita entradas não analisáveis.

DeleteResultSchema

const DeleteResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  deleted_count: ZodNumber;
}, $loose>;

DocumentBlockSchema

const DocumentBlockSchema: ZodObject<{
  filename: ZodOptional<ZodString>;
  mime_type: ZodOptional<ZodString>;
  type: ZodDefault<ZodLiteral<"document">>;
  url: ZodString;
}, $strip>;

Bloqueio de conteúdo de documento/arquivo.

EventResponseSchema

const EventResponseSchema: ZodObject<{
  event: ZodObject<{
     actor_id: ZodString;
     branch: ZodOptional<ZodObject<{
        name: ZodString;
        root_event_id: ZodString;
     }, $loose>>;
     event_id: ZodString;
     metadata: ZodOptional<ZodRecord<ZodString, ZodString>>;
     parent_event_id: ZodOptional<ZodString>;
     payload: ZodPipe<ZodUnknown, ZodTransform<
        | string
        | number
        | boolean
        | JsonValue[]
        | {
      [key: string]: JsonValue;
      }
       | null, unknown>>;
     session_id: ZodString;
     timestamp: ZodPipe<ZodString, ZodTransform<Date, string>>;
  }, $loose>;
}, $loose>;

EventSchema

const EventSchema: ZodObject<{
  actor_id: ZodString;
  branch: ZodOptional<ZodObject<{
     name: ZodString;
     root_event_id: ZodString;
  }, $loose>>;
  event_id: ZodString;
  metadata: ZodOptional<ZodRecord<ZodString, ZodString>>;
  parent_event_id: ZodOptional<ZodString>;
  payload: ZodPipe<ZodUnknown, ZodTransform<
     | string
     | number
     | boolean
     | JsonValue[]
     | {
   [key: string]: JsonValue;
   }
    | null, unknown>>;
  session_id: ZodString;
  timestamp: ZodPipe<ZodString, ZodTransform<Date, string>>;
}, $loose>;

evento de plataforma — o envelope de armazenamento. As cargas úteis são opacas.

EventsResponseSchema

const EventsResponseSchema: ZodObject<{
  events: ZodArray<ZodObject<{
     actor_id: ZodString;
     branch: ZodOptional<ZodObject<{
        name: ZodString;
        root_event_id: ZodString;
     }, $loose>>;
     event_id: ZodString;
     metadata: ZodOptional<ZodRecord<ZodString, ZodString>>;
     parent_event_id: ZodOptional<ZodString>;
     payload: ZodPipe<ZodUnknown, ZodTransform<
        | string
        | number
        | boolean
        | JsonValue[]
        | {
      [key: string]: JsonValue;
      }
       | null, unknown>>;
     session_id: ZodString;
     timestamp: ZodPipe<ZodString, ZodTransform<Date, string>>;
  }, $loose>>;
}, $loose>;

FormatStyle

FormatStyle: object;

Declaração de tipo

Nome
Tipo

CLAUDE

"claude"

JINJA2

"jinja2"

OPENAI

"openai"

FormatStyleSchema

const FormatStyleSchema: ZodEnum<{
  claude: "claude";
  jinja2: "jinja2";
  openai: "openai";
}>;

ImageBlockSchema

const ImageBlockSchema: ZodObject<{
  mime_type: ZodOptional<ZodString>;
  type: ZodDefault<ZodLiteral<"image">>;
  url: ZodString;
}, $strip>;

Bloco de conteúdo da imagem.

InternalStateResultSchema

const InternalStateResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  content_hash: ZodString;
  previous_version: ZodOptional<ZodNumber>;
  session_id: ZodString;
  token_count: ZodNumber;
  version: ZodNumber;
  was_noop: ZodBoolean;
}, $loose>;

ISGenerationResultSchema

const ISGenerationResultSchema: ZodObject<{
  coalesced: ZodBoolean;
  content_hash: ZodOptional<ZodString>;
  events_hash: ZodOptional<ZodString>;
  model_id: ZodOptional<ZodString>;
  next_update_at: ZodOptional<ZodString>;
  previous_version: ZodOptional<ZodNumber>;
  skipped_reason: ZodOptional<ZodString>;
  token_count: ZodOptional<ZodNumber>;
  updated: ZodBoolean;
  version: ZodOptional<ZodNumber>;
  was_noop: ZodBoolean;
}, $loose>;

JsonValueSchema

const JsonValueSchema: z.ZodType<JsonValue>;

Esquema de tempo de execução para o tipo JsonValue recursivo.

LLMInvocaçãoOptionsSchema

const LLMInvocationOptionsSchema: ZodPreprocess<ZodPipe<ZodObject<{
  frequency_penalty: ZodOptional<ZodNumber>;
  max_tokens: ZodOptional<ZodNumber>;
  parallel_tool_calls: ZodOptional<ZodBoolean>;
  presence_penalty: ZodOptional<ZodNumber>;
  reasoning_effort: ZodOptional<ZodString>;
  response_format: ZodOptional<ZodType<JsonValue, unknown, $ZodTypeInternals<JsonValue, unknown>>>;
  seed: ZodOptional<ZodNumber>;
  timeout: ZodOptional<ZodNumber>;
  top_k: ZodOptional<ZodNumber>;
  top_p: ZodOptional<ZodNumber>;
}, $loose>, ZodTransform<LLMInvocationOptions, {
[key: string]: unknown;
  frequency_penalty?: number;
  max_tokens?: number;
  parallel_tool_calls?: boolean;
  presence_penalty?: number;
  reasoning_effort?: string;
  response_format?: JsonValue;
  seed?: number;
  timeout?: number;
  top_k?: number;
  top_p?: number;
}>>>;

Esquema de validação de tempo de execução para dados de fio LLMIn invokeOptions.

LLMResponseSchema

const LLMResponseSchema: ZodObject<{
  additional_kwargs: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
  content: ZodString;
  id: ZodOptional<ZodString>;
  metadata: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
  name: ZodOptional<ZodString>;
  response_metadata: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
  tool_calls: ZodOptional<ZodArray<ZodUnknown>>;
  usage: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
}, $loose>;

Esquema de validação de tempo de execução para dados de fio do LLMResponse. content é o único campo obrigatório.

LLMTokenUsageSchema

const LLMTokenUsageSchema: ZodPreprocess<ZodPipe<ZodObject<{
  completion_tokens: ZodOptional<ZodNumber>;
  input_tokens: ZodOptional<ZodNumber>;
  model: ZodOptional<ZodString>;
  output_tokens: ZodOptional<ZodNumber>;
  prompt_tokens: ZodOptional<ZodNumber>;
  total_tokens: ZodOptional<ZodNumber>;
}, $strip>, ZodTransform<LLMTokenUsage, {
  completion_tokens?: number;
  input_tokens?: number;
  model?: string;
  output_tokens?: number;
  prompt_tokens?: number;
  total_tokens?: number;
}>>>;

Esquema de validação de tempo de execução para dados de conexão LLMTokenUsage. Todos os campos opcionais, correspondendo ao construtor da classe .

LLMToolCallSchema

const LLMToolCallSchema: ZodPipe<ZodObject<{
  args: ZodOptional<ZodType<JsonValue, unknown, $ZodTypeInternals<JsonValue, unknown>>>;
  arguments: ZodOptional<ZodType<JsonValue, unknown, $ZodTypeInternals<JsonValue, unknown>>>;
  id: ZodOptional<ZodString>;
  index: ZodOptional<ZodNumber>;
  name: ZodOptional<ZodString>;
  type: ZodOptional<ZodString>;
}, $strip>, ZodTransform<LLMToolCall, {
  args?: JsonValue;
  arguments?: JsonValue;
  id?: string;
  index?: number;
  name?: string;
  type?: string;
}>>;

Esquema de validação de tempo de execução para dados de fio do LLMToolCall.

LLMToolSchemaValidator

const LLMToolSchemaValidator: ZodPipe<ZodObject<{
  description: ZodOptional<ZodString>;
  function: ZodOptional<ZodType<JsonValue, unknown, $ZodTypeInternals<JsonValue, unknown>>>;
  name: ZodOptional<ZodString>;
  parameters: ZodOptional<ZodType<JsonValue, unknown, $ZodTypeInternals<JsonValue, unknown>>>;
  strict: ZodOptional<ZodBoolean>;
  type: ZodOptional<ZodString>;
}, $strip>, ZodTransform<LLMToolSchema, {
  description?: string;
  function?: JsonValue;
  name?: string;
  parameters?: JsonValue;
  strict?: boolean;
  type?: string;
}>>;

Esquema de validação de tempo de execução para dados de fio do LLMToolSchema.

MemoryChunkSchema

const MemoryChunkSchema: ZodObject<{
  content: ZodString;
  embedding: ZodOptional<ZodArray<ZodNumber>>;
  id: ZodString;
  metadata: ZodOptional<ZodRecord<ZodString, ZodUnknown>>;
  similarity_score: ZodOptional<ZodNumber>;
  source: ZodEnum<{
     episodic: "episodic";
     procedural: "procedural";
     semantic: "semantic";
     stm: "stm";
     taxonomic: "taxonomic";
  }>;
  timestamp: ZodPipe<ZodString, ZodTransform<Date, string>>;
}, $loose>;

Representação unificada de um chunk de memória recuperado em todos os tipos de memória.

Fonte de memória

MemorySource: object;

Declaração de tipo

Nome
Tipo

EPISODIC

"episodic"

PROCEDURAL

"procedural"

SEMANTIC

"semantic"

STM

"stm"

TAXONOMIC

"taxonomic"

MemorySourceSchema

const MemorySourceSchema: ZodEnum<{
  episodic: "episodic";
  procedural: "procedural";
  semantic: "semantic";
  stm: "stm";
  taxonomic: "taxonomic";
}>;

MessageSchema

const MessageSchema: ZodPipe<ZodObject<{
  additional_kwargs: ZodOptional<ZodRecord<ZodString, ZodType<JsonValue, unknown, $ZodTypeInternals<JsonValue, unknown>>>>;
  content: ZodUnion<readonly [ZodString, ZodArray<ZodDiscriminatedUnion<[ZodObject<{
     text: ZodString;
     type: ZodDefault<...>;
   }, $strip>, ZodObject<{
     mime_type: ZodOptional<...>;
     type: ZodDefault<...>;
     url: ZodString;
   }, $strip>, ZodObject<{
     filename: ZodOptional<...>;
     mime_type: ZodOptional<...>;
     type: ZodDefault<...>;
     url: ZodString;
  }, $strip>], "type">>]>;
  id: ZodOptional<ZodString>;
  is_error: ZodOptional<ZodBoolean>;
  name: ZodOptional<ZodString>;
  response_metadata: ZodOptional<ZodRecord<ZodString, ZodType<JsonValue, unknown, $ZodTypeInternals<JsonValue, unknown>>>>;
  role: ZodEnum<{
     assistant: "assistant";
     system: "system";
     tool: "tool";
     user: "user";
  }>;
  tool_call_id: ZodOptional<ZodString>;
  tool_calls: ZodOptional<ZodArray<ZodPipe<ZodObject<{
     args: ZodOptional<ZodType<JsonValue, unknown, $ZodTypeInternals<..., ...>>>;
     arguments: ZodOptional<ZodType<JsonValue, unknown, $ZodTypeInternals<..., ...>>>;
     id: ZodOptional<ZodString>;
     index: ZodOptional<ZodNumber>;
     name: ZodOptional<ZodString>;
     type: ZodOptional<ZodString>;
   }, $strip>, ZodTransform<LLMToolCall, {
     args?: JsonValue;
     arguments?: JsonValue;
     id?: string;
     index?: number;
     name?: string;
     type?: string;
  }>>>>;
}, $loose>, ZodTransform<Message, {
[key: string]: unknown;
  additional_kwargs?: Record<string, JsonValue>;
  content:   | string
     | (
     | {
     text: string;
     type: "text";
   }
     | {
     mime_type?: string;
     type: "image";
     url: string;
   }
     | {
     filename?: string;
     mime_type?: string;
     type: "document";
     url: string;
   })[];
  id?: string;
  is_error?: boolean;
  name?: string;
  response_metadata?: Record<string, JsonValue>;
  role: "user" | "assistant" | "tool" | "system";
  tool_call_id?: string;
  tool_calls?: LLMToolCall[];
}>>;

Esquema de validação de tempo de execução para dados de fio de Mensagem. Analisa campos de fio snake_case e os transforma na forma de interface de mensagem camelCase, correspondendo a como o LLMToolCallSchema/LLMTokenUsageSchema lida com o mesmo mapeamento.

ModelType

ModelType: object;

Declaração de tipo

Nome
Tipo

ANTHROPIC

"anthropic"

CLAUDE

"claude"

GEMINI

"gemini"

GENERIC

"generic"

OPENAI

"openai"

ModelTypeSchema

const ModelTypeSchema: ZodEnum<{
  anthropic: "anthropic";
  claude: "claude";
  gemini: "gemini";
  generic: "generic";
  openai: "openai";
}>;

PromoverSnapshotResultSchema

const PromoteSnapshotResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  has_embedding: ZodDefault<ZodBoolean>;
  promoted_count: ZodNumber;
  reason: ZodString;
  session_id: ZodString;
  snapshot_id: ZodOptional<ZodString>;
}, $loose>;

RetrievedCustomMemorySchema

const RetrievedCustomMemorySchema: ZodObject<{
  agent_id: ZodOptional<ZodNullable<ZodString>>;
  content: ZodString;
  contextual_metadata: ZodOptional<ZodNullable<ZodRecord<ZodString, ZodUnknown>>>;
  id: ZodString;
  tags: ZodRecord<ZodString, ZodUnion<readonly [ZodString, ZodNumber, ZodBoolean]>>;
  type: ZodString;
  user_id: ZodOptional<ZodNullable<ZodString>>;
}, $strip>;

SessionMessageSchema

const SessionMessageSchema: ZodObject<{
  additional_kwargs: ZodDefault<ZodNullable<ZodRecord<ZodString, ZodUnknown>>>;
  content: ZodString;
  id: ZodString;
  name: ZodDefault<ZodString>;
  role: ZodString;
  session_id: ZodString;
  timestamp: ZodString;
  tool_call_id: ZodDefault<ZodNullable<ZodString>>;
  tool_calls: ZodDefault<ZodNullable<ZodArray<ZodPipe<ZodObject<{
     args: ZodOptional<ZodType<JsonValue, unknown, $ZodTypeInternals<..., ...>>>;
     arguments: ZodOptional<ZodType<JsonValue, unknown, $ZodTypeInternals<..., ...>>>;
     id: ZodOptional<ZodString>;
     index: ZodOptional<ZodNumber>;
     name: ZodOptional<ZodString>;
     type: ZodOptional<ZodString>;
   }, $strip>, ZodTransform<LLMToolCall, {
     args?: JsonValue;
     arguments?: JsonValue;
     id?: string;
     index?: number;
     name?: string;
     type?: string;
  }>>>>>;
}, $strip>;

Uma única mensagem no histórico de conversa de uma sessão.

role usa o mesmo vocabulário que Message ("usuário", "assistante", "tool", "system"). name carrega o nome da ferramenta em mensagens de ferramenta.

Simula o SessionMessage do Python em agent_engine_sdk/models.py.

SessionMessagesResponseSchema

const SessionMessagesResponseSchema: ZodObject<{
  messages: ZodArray<ZodObject<{
     additional_kwargs: ZodDefault<ZodNullable<ZodRecord<ZodString, ZodUnknown>>>;
     content: ZodString;
     id: ZodString;
     name: ZodDefault<ZodString>;
     role: ZodString;
     session_id: ZodString;
     timestamp: ZodString;
     tool_call_id: ZodDefault<ZodNullable<ZodString>>;
     tool_calls: ZodDefault<ZodNullable<ZodArray<ZodPipe<ZodObject<{
        args: ...;
        arguments: ...;
        id: ...;
        index: ...;
        name: ...;
        type: ...;
      }, $strip>, ZodTransform<LLMToolCall, {
        args?: ...;
        arguments?: ...;
        id?: ...;
        index?: ...;
        name?: ...;
        type?: ...;
     }>>>>>;
  }, $strip>>;
}, $strip>;

Resposta para o endpoint de mensagens de sessão da AER.

SessionsSummaryResponseSchema

const SessionsSummaryResponseSchema: ZodObject<{
  sessions: ZodArray<ZodObject<{
     created_at: ZodString;
     first_message_preview: ZodDefault<ZodString>;
     last_activity: ZodString;
     message_count: ZodNumber;
     session_id: ZodString;
  }, $strip>>;
}, $strip>;

Resposta para o endpoint de enriquecimento do resumo da sessão da AER.

SessionSummarySchema

const SessionSummarySchema: ZodObject<{
  created_at: ZodString;
  first_message_preview: ZodDefault<ZodString>;
  last_activity: ZodString;
  message_count: ZodNumber;
  session_id: ZodString;
}, $strip>;

Resumo por sessão obtido da persistência específica da estrutura.

Retornado pelo endpoint de enriquecimento de sessão do AER. A camada da plataforma (OE) mescla isso com seus próprios campos de locatário (user_id, project_id, workspace_id, visibilidade) ao montar a lista de sessões públicas.

Simula o SessionSummary do Python em agent_engine_sdk/models.py.

StreamEventSchema

const StreamEventSchema: ZodObject<{
  data: ZodUnknown & ZodType<
     | {
   }
     | null, unknown, $ZodTypeInternals<
     | {
   }
    | null, unknown>>;
  event: ZodOptional<ZodString>;
}, $loose>;

Esquema de validação de tempo de execução para dados de fio StreamEvent.

TagScalarSchema

const TagScalarSchema: ZodUnion<readonly [ZodString, ZodNumber, ZodBoolean]>;

TextBlockSchema

const TextBlockSchema: ZodObject<{
  text: ZodString;
  type: ZodDefault<ZodLiteral<"text">>;
}, $strip>;

Bloqueio de conteúdo de texto.

ToolCallChunkSchema

const ToolCallChunkSchema: ZodObject<{
  args: ZodOptional<ZodString>;
  id: ZodOptional<ZodString>;
  index: ZodOptional<ZodNumber>;
  name: ZodOptional<ZodString>;
  type: ZodOptional<ZodString>;
}, $strip>;

Esquema de validação de tempo de execução para dados de fio do ToolCallChunk.

ToolDefinitionSchema

const ToolDefinitionSchema: ZodObject<{
  args_schema: ZodRecord<ZodString, ZodUnknown>;
  callable: ZodCustom<(...args) => unknown, (...args) => unknown>;
  description: ZodString;
  name: ZodString;
  network: ZodDefault<ZodArray<ZodString>>;
  provider_type: ZodOptional<ZodString>;
  redact_fields: ZodDefault<ZodArray<ZodString>>;
  remote: ZodDefault<ZodBoolean>;
  scopes: ZodDefault<ZodArray<ZodString>>;
  timeout_seconds: ZodDefault<ZodNumber>;
}, $strip>;

Definição de ferramenta independente de framework.

WriteTurnResultSchema

const WriteTurnResultSchema: ZodObject<{
  acknowledged: ZodBoolean;
  id: ZodString;
  session_id: ZodString;
  turn_seq: ZodNumber;
}, $loose>;

Funções

createToolDefinition()

function createToolDefinition(input): object;

Constrói uma ToolDefinition, aplicando os padrões de paridade Python (remota=true, rede=[], timeout_seconds=30, redact_fields=[]).

Parâmetros

Parâmetro
Tipo

input

{ args_schema: Record <string, unknown>; callable: (… args) => unknown; description: string; name: string; network?: string []; provider_type?: string; redact_fields?: string []; remote?: boolean; scopes?: string []; timeout_seconds?: number; }

input.args_schema

Record <string, unknown>

input.callable

(… args) => unknown

input.description

string

input.name

string

input.network?

string []

input.provider_type?

string

input.redact_fields?

string []

input.remote?

boolean

input.scopes?

string []

input.timeout_seconds?

number

Devoluções

object

Nome
Tipo

args_schema

Record <string, unknown>

callable()

(… args) => unknown

description

string

name

string

network

string []

provider_type?

string

redact_fields

string []

remote

boolean

scopes

string []

timeout_seconds

number

serializeMessage()

function serializeMessage(message): Record<string, unknown>;

Serialize uma mensagem para sua forma de fio snake_case — a metade camel→snake “dump” que espelha o model_dump(by_alias=True) do Python. MessageSchema é a metade inversa da cobra→camel “parse”.

Manter esses dois simétricos é o que torna a representação segura: as mensagens são camelCase internamente (a interface Message) e snake_case na conexão, e a conversão ocorre exatamente uma vez em cada limite. Use isso ao despejar um Message já interno; nunca execute novamente uma mensagem interna por meio de MessageSchema, cuja transformação deixaria em branco os campos camelCase.

Parâmetros

Parâmetro
Tipo

message

`Message <#message>`__

Devoluções

Record <string, unknown>

Voltar
Agent-engine-sdk
Próximo
agente-engine-sdk-langgraph
Avalie esta página