WeaveClient

projectId : string

settings : object

readonly attributes: Record<string, any>

readonly genai : objet

optional batchOptions : BufferConfig

optional spanProcessor: "batch" | "simple" | SpanProcessor

• 'batch' (par défaut) : BatchSpanProcessor, adapté aux agents en production et aux processus de longue durée.
• 'simple' : SimpleSpanProcessor, une requête HTTP POST par span. Utile pour les tests et les CLI de courte durée, lorsqu’un vidage déterministe importe plus que le débit.
• Instance de SpanProcessor : un processor fourni par l’utilisateur. L’appelant gère son cycle de vie ; l’exporter OTLP de Weave ciblant /agents/otel/v1/traces n’est pas utilisé.

readonly printCallLink: boolean

useCallsComplete : boolean

useOTelV2 : boolean

traceServerApi: Api<any>

addScore(predictCallId, scorerCallId, runnableRefUri, scorerOutput) : Promise<string>

createCall(internalCall, opRef, params, parameterNames, thisArg, currentCall, parentCall, startTime, displayName?, attributes?, eagerCallStart?) : Promise<void>

finishCall(call, result, currentCall, parentCall, summarize, endTime, startCallPromise): Promise<void>

finishCallWithException(call, error, currentCall, parentCall, endTime, startCallPromise): Promise<void>

flush(): Promise<void>

get(ref) : Promise<any>

getAgentCustomAttributes(options): Promise<Réponse<{ attributes?: object[]; has_more?: boolean; limit?: number; offset?: number; }>>

200

0

const client = await weave.init('entity/project');
const resp = await client.getAgentCustomAttributes({
  query: {
    $expr: {
      $eq: [{$getField: 'agent_name'}, {$literal: 'my-agent'}],
    },
  },
  startedAfter: '2026-06-15T00:00:00Z',
  limit: 200,
});

for (const attr of resp.data.attributes ?? []) {
  console.log(`${attr.source}.${attr.key} (${attr.value_type}): ${attr.span_count}`);
}

getAgents(options?): Promise<Réponse<GetAgentsResult>>

const client = await weave.init('entity/project');
const resp = await client.getAgents({limit: 20});

for (const agent of resp.data.agents) {
  console.log(agent.agent_name, agent.total_input_tokens);
}

console.log(`total count: ${resp.data.total_count}`)

getAgentSpans(options) : Promise<Réponse<GetAgentSpansResult>>

const client = await weave.init('entity/project');
const resp = await client.getAgentSpans({agentName: 'my-agent', limit: 20});

for (const span of resp.data.spans) {
  console.log(span.span_id, span.span_name, span.input_tokens);
}

const client = await weave.init('entity/project');

const resp = await client.getAgentSpans({
  agentName: 'my-agent',
  query: {
    $expr: {$gt: [{$getField: 'input_tokens'}, {$literal: 1000}]},
  },
});

for (const span of resp.data.spans) {
  console.log(span.span_id, span.span_name, span.input_tokens);
}

getAgentSpanStats(options) : Promise<Réponse<{ bucket_type?: "number" | "time"; columns?: object[]; end: string; granularity?: number | null; rows?: Record<string, string | number | boolean | null>[]; start: string; timezone: string; }>>

"UTC"

const client = await weave.init('entity/project');
const resp = await client.getAgentSpanStats({
  start: '2026-06-10T00:00:00Z',
  end: '2026-06-23T00:00:00Z',
  granularity: 86400, // une ligne par jour
  metrics: [
    {
      alias: 'total_input_tokens',
      value_type: 'number',
      aggregations: ['sum'],
      value: {source: 'field', key: 'input_tokens'},
    },
  ],
  groupBy: [{key: 'agent_name'}],
});

for (const row of resp.data.rows ?? []) {
  console.log(row.started_at_bucket, row.agent_name, row.total_input_tokens);
}

getAgentTurn(options) : Promise<Réponse<{ agent_name?: string | null; agent_version?: string | null; feedback?: Record<string, any>[] | null; messages?: object[]; provider?: string | null; root_span_name?: string | null; status_code?: "UNSET" | "OK" | "ERROR" | null; total_cost_usd?: number | null; total_duration_ms?: number | null; trace_id: string; }>>

const client = await weave.init('entity/project');
const resp = await client.getAgentTurn({
  traceId: '01997b8a-2c89-7c4d-9d0e-2f7e5b9a1b2c',
  includeFeedback: true,
});

console.log(resp.data.root_span_name, resp.data.total_duration_ms);

for (const message of resp.data.messages ?? []) {
  if (message.user_message) console.log('user:', message.user_message);
  if (message.assistant_message) console.log('assistant:', message.assistant_message);
}

getAgentTurns(options): Promise<Réponse<GetAgentTurnsResult>>

const client = await weave.init('entity/project');
const resp = await client.getAgentTurns({
  conversationId: 'trace_c50312356de3487fa90e381c9399b5b4',
  limit: 20,
  includeFeedback: true,
});

for (const turn of resp.data.turns ?? []) {
  console.log(turn.trace_id, turn.root_span_name);
  for (const message of turn.messages ?? []) {
    if (message.user_message) console.log('user:', message.user_message);
    if (message.assistant_message) console.log('assistant:', message.assistant_message);
  }
}

console.log(`total turns: ${resp.data.total_turns}, has more: ${resp.data.has_more}`);

getAgentVersions(options) : Promise<Réponse<GetAgentVersionsResult>>

const client = await weave.init('entity/project');
const resp = await client.getAgentVersions({agentName: 'my-agent', limit: 20});

for (const version of resp.data.versions) {
  console.log(version.agent_version, version.total_input_tokens);
}

console.log(`total count: ${resp.data.total_count}`)

getCall(callId, includeCosts?): Promise<{ attributes: Record<string, any>; deleted_at?: string | null; display_name?: string | null; ended_at?: string | null; exception?: string | null; expire_at?: string | null; id: string; inputs: Record<string, any>; op_name: string; output?: null; parent_id?: string | null; project_id: string; started_at: string; storage_size_bytes?: number | null; summary?: Record<string, any>; thread_id?: string | null; total_storage_size_bytes?: number | null; trace_id: string; turn_id?: string | null; wb_run_id?: string | null; wb_run_step?: number | null; wb_run_step_end?: number | null; wb_user_id?: string | null; wb_username?: string | null; setDisplayName: Promise<void>; }>

getCalls(options?): Promise<objet[]>

getCalls(options?, includeCosts?, limit?): Promise<objet[]>

getCallsIterator(options?, includeCosts?, limit?): AsyncIterableIterator<CallSchema>

getCallsIterator(options?): AsyncIterableIterator<CallSchema>

getCallStack(): CallStack

getCurrentAttributes(): Record<string, any>

linkPromptToRegistry(prompt, options): Promise<{ version_index: number | null; }>

pendingCallCount(): number

publish(obj, objId?): Promise<ObjectRef>

pushNewCall() : objet

registerCustomRuntime(options) : Promise<Réponse<{ api_key_secret: string | null; base_url: string; headers: Record<string, string>; name: string; runtime_ids: objet[]; }>>

runWithAttributes<T>(attributes, fn): T

runWithCallStack<T>(callStack, fn) : T

saveCallEnd(callEnd) : void

saveCallStart(callStart, opts?) : void

saveOp(op, objId?): Promise<OpRef>

searchAgents(options) : Promise<Réponse<{ results: objet[]; total_conversations?: number; }>>

20

0

const client = await weave.init('entity/project');
const resp = await client.searchAgents({
  query: 'Liverpool',
  agentName: 'Assistant',
  limit: 20,
});

for (const conversation of resp.data.results ?? []) {
  console.log(`${conversation.conversation_id} (${conversation.agent_name})`);
  for (const match of conversation.matched_messages) {
    console.log(`  [${match.role}] ${match.content_preview}`);
  }
}

console.log(`total conversations: ${resp.data.total_conversations}`);

serializeAudio(data, audioType?): Promise<{ _type: "CustomWeaveType"; files: Record<string, string>; load_op: string; weave_type: { type: string; }; }>

updateCall(callId, displayName) : Promise<void>

waitForBatchProcessing(): Promise<void>