@ondewo/nlu-client-typescript 6.10.0 → 6.12.0

package/api/ondewo/nlu/session_pb.d.ts

@@ -7,10 +7,12 @@ import * as google_protobuf_struct_pb from 'google-protobuf/google/protobuf/stru
 import * as google_protobuf_timestamp_pb from 'google-protobuf/google/protobuf/timestamp_pb'; // proto import: "google/protobuf/timestamp.proto"
 import * as google_rpc_status_pb from '../../google/rpc/status_pb'; // proto import: "google/rpc/status.proto"
 import * as google_type_latlng_pb from '../../google/type/latlng_pb'; // proto import: "google/type/latlng.proto"
+import * as ondewo_nlu_ccai_project_pb from '../../ondewo/nlu/ccai_project_pb'; // proto import: "ondewo/nlu/ccai_project.proto"
 import * as ondewo_nlu_common_pb from '../../ondewo/nlu/common_pb'; // proto import: "ondewo/nlu/common.proto"
 import * as ondewo_nlu_context_pb from '../../ondewo/nlu/context_pb'; // proto import: "ondewo/nlu/context.proto"
-import * as ondewo_nlu_intent_pb from '../../ondewo/nlu/intent_pb'; // proto import: "ondewo/nlu/intent.proto"
 import * as ondewo_nlu_entity_type_pb from '../../ondewo/nlu/entity_type_pb'; // proto import: "ondewo/nlu/entity_type.proto"
+import * as ondewo_nlu_intent_pb from '../../ondewo/nlu/intent_pb'; // proto import: "ondewo/nlu/intent.proto"
+import * as ondewo_nlu_llm_evaluation_pb from '../../ondewo/nlu/llm_evaluation_pb'; // proto import: "ondewo/nlu/llm_evaluation.proto"
 
 
 export class DetectIntentRequest extends jspb.Message {
@@ -63,6 +65,11 @@ export class DetectIntentResponse extends jspb.Message {
   hasWebhookStatus(): boolean;
   clearWebhookStatus(): DetectIntentResponse;
 
+  getLlmTelemetryReport(): LlmTelemetryReport | undefined;
+  setLlmTelemetryReport(value?: LlmTelemetryReport): DetectIntentResponse;
+  hasLlmTelemetryReport(): boolean;
+  clearLlmTelemetryReport(): DetectIntentResponse;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): DetectIntentResponse.AsObject;
   static toObject(includeInstance: boolean, msg: DetectIntentResponse): DetectIntentResponse.AsObject;
@@ -76,6 +83,7 @@ export namespace DetectIntentResponse {
     responseId: string,
     queryResult?: QueryResult.AsObject,
     webhookStatus?: google_rpc_status_pb.Status.AsObject,
+    llmTelemetryReport?: LlmTelemetryReport.AsObject,
   }
 }
 
@@ -270,6 +278,1470 @@ export namespace QueryInput {
   }
 }
 
+export class LlmTokenUsage extends jspb.Message {
+  getTotalTokens(): number;
+  setTotalTokens(value: number): LlmTokenUsage;
+
+  getInputTokens(): number;
+  setInputTokens(value: number): LlmTokenUsage;
+
+  getOutputTokens(): number;
+  setOutputTokens(value: number): LlmTokenUsage;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmTokenUsage.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmTokenUsage): LlmTokenUsage.AsObject;
+  static serializeBinaryToWriter(message: LlmTokenUsage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmTokenUsage;
+  static deserializeBinaryFromReader(message: LlmTokenUsage, reader: jspb.BinaryReader): LlmTokenUsage;
+}
+
+export namespace LlmTokenUsage {
+  export type AsObject = {
+    totalTokens: number,
+    inputTokens: number,
+    outputTokens: number,
+  }
+}
+
+export class LlmToolCallMetadata extends jspb.Message {
+  getToolCallId(): string;
+  setToolCallId(value: string): LlmToolCallMetadata;
+
+  getToolName(): string;
+  setToolName(value: string): LlmToolCallMetadata;
+
+  getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): LlmToolCallMetadata;
+  hasStartTime(): boolean;
+  clearStartTime(): LlmToolCallMetadata;
+
+  getEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setEndTime(value?: google_protobuf_timestamp_pb.Timestamp): LlmToolCallMetadata;
+  hasEndTime(): boolean;
+  clearEndTime(): LlmToolCallMetadata;
+
+  getDurationInS(): number;
+  setDurationInS(value: number): LlmToolCallMetadata;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmToolCallMetadata;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmToolCallMetadata;
+
+  getArguments(): google_protobuf_struct_pb.Struct | undefined;
+  setArguments(value?: google_protobuf_struct_pb.Struct): LlmToolCallMetadata;
+  hasArguments(): boolean;
+  clearArguments(): LlmToolCallMetadata;
+
+  getResult(): google_protobuf_struct_pb.Struct | undefined;
+  setResult(value?: google_protobuf_struct_pb.Struct): LlmToolCallMetadata;
+  hasResult(): boolean;
+  clearResult(): LlmToolCallMetadata;
+
+  getErrorMessage(): string;
+  setErrorMessage(value: string): LlmToolCallMetadata;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmToolCallMetadata.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmToolCallMetadata): LlmToolCallMetadata.AsObject;
+  static serializeBinaryToWriter(message: LlmToolCallMetadata, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmToolCallMetadata;
+  static deserializeBinaryFromReader(message: LlmToolCallMetadata, reader: jspb.BinaryReader): LlmToolCallMetadata;
+}
+
+export namespace LlmToolCallMetadata {
+  export type AsObject = {
+    toolCallId: string,
+    toolName: string,
+    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    durationInS: number,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+    arguments?: google_protobuf_struct_pb.Struct.AsObject,
+    result?: google_protobuf_struct_pb.Struct.AsObject,
+    errorMessage: string,
+  }
+}
+
+export class LlmThinkingMetadata extends jspb.Message {
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmThinkingMetadata;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmThinkingMetadata;
+
+  getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): LlmThinkingMetadata;
+  hasStartTime(): boolean;
+  clearStartTime(): LlmThinkingMetadata;
+
+  getEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setEndTime(value?: google_protobuf_timestamp_pb.Timestamp): LlmThinkingMetadata;
+  hasEndTime(): boolean;
+  clearEndTime(): LlmThinkingMetadata;
+
+  getDurationInS(): number;
+  setDurationInS(value: number): LlmThinkingMetadata;
+
+  getThinkingText(): string;
+  setThinkingText(value: string): LlmThinkingMetadata;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmThinkingMetadata.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmThinkingMetadata): LlmThinkingMetadata.AsObject;
+  static serializeBinaryToWriter(message: LlmThinkingMetadata, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmThinkingMetadata;
+  static deserializeBinaryFromReader(message: LlmThinkingMetadata, reader: jspb.BinaryReader): LlmThinkingMetadata;
+}
+
+export namespace LlmThinkingMetadata {
+  export type AsObject = {
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    durationInS: number,
+    thinkingText: string,
+  }
+}
+
+export class LlmTelemetry extends jspb.Message {
+  getProvider(): string;
+  setProvider(value: string): LlmTelemetry;
+
+  getModelName(): string;
+  setModelName(value: string): LlmTelemetry;
+
+  getAgentName(): string;
+  setAgentName(value: string): LlmTelemetry;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmTelemetry;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmTelemetry;
+
+  getLlmToolCallMetadatasList(): Array<LlmToolCallMetadata>;
+  setLlmToolCallMetadatasList(value: Array<LlmToolCallMetadata>): LlmTelemetry;
+  clearLlmToolCallMetadatasList(): LlmTelemetry;
+  addLlmToolCallMetadatas(value?: LlmToolCallMetadata, index?: number): LlmToolCallMetadata;
+
+  getToolCallCount(): number;
+  setToolCallCount(value: number): LlmTelemetry;
+
+  getLlmThinkingMetadata(): LlmThinkingMetadata | undefined;
+  setLlmThinkingMetadata(value?: LlmThinkingMetadata): LlmTelemetry;
+  hasLlmThinkingMetadata(): boolean;
+  clearLlmThinkingMetadata(): LlmTelemetry;
+
+  getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): LlmTelemetry;
+  hasStartTime(): boolean;
+  clearStartTime(): LlmTelemetry;
+
+  getEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setEndTime(value?: google_protobuf_timestamp_pb.Timestamp): LlmTelemetry;
+  hasEndTime(): boolean;
+  clearEndTime(): LlmTelemetry;
+
+  getDurationInS(): number;
+  setDurationInS(value: number): LlmTelemetry;
+
+  getRunId(): string;
+  setRunId(value: string): LlmTelemetry;
+
+  getParentRunId(): string;
+  setParentRunId(value: string): LlmTelemetry;
+
+  getRunType(): string;
+  setRunType(value: string): LlmTelemetry;
+
+  getComponentName(): string;
+  setComponentName(value: string): LlmTelemetry;
+
+  getTagsList(): Array<string>;
+  setTagsList(value: Array<string>): LlmTelemetry;
+  clearTagsList(): LlmTelemetry;
+  addTags(value: string, index?: number): LlmTelemetry;
+
+  getMetadata(): google_protobuf_struct_pb.Struct | undefined;
+  setMetadata(value?: google_protobuf_struct_pb.Struct): LlmTelemetry;
+  hasMetadata(): boolean;
+  clearMetadata(): LlmTelemetry;
+
+  getInputs(): google_protobuf_struct_pb.Struct | undefined;
+  setInputs(value?: google_protobuf_struct_pb.Struct): LlmTelemetry;
+  hasInputs(): boolean;
+  clearInputs(): LlmTelemetry;
+
+  getOutputs(): google_protobuf_struct_pb.Struct | undefined;
+  setOutputs(value?: google_protobuf_struct_pb.Struct): LlmTelemetry;
+  hasOutputs(): boolean;
+  clearOutputs(): LlmTelemetry;
+
+  getErrorClass(): string;
+  setErrorClass(value: string): LlmTelemetry;
+
+  getErrorMessage(): string;
+  setErrorMessage(value: string): LlmTelemetry;
+
+  getTraceback(): string;
+  setTraceback(value: string): LlmTelemetry;
+
+  getStreamingChunkCount(): number;
+  setStreamingChunkCount(value: number): LlmTelemetry;
+
+  getFirstTokenLatencySeconds(): number;
+  setFirstTokenLatencySeconds(value: number): LlmTelemetry;
+
+  getSystemFingerprint(): string;
+  setSystemFingerprint(value: string): LlmTelemetry;
+
+  getCached(): boolean;
+  setCached(value: boolean): LlmTelemetry;
+
+  getRetryCount(): number;
+  setRetryCount(value: number): LlmTelemetry;
+
+  getFallbackDepth(): number;
+  setFallbackDepth(value: number): LlmTelemetry;
+
+  getTemperature(): number;
+  setTemperature(value: number): LlmTelemetry;
+
+  getTopP(): number;
+  setTopP(value: number): LlmTelemetry;
+
+  getMaxTokens(): number;
+  setMaxTokens(value: number): LlmTelemetry;
+
+  getNGenerations(): number;
+  setNGenerations(value: number): LlmTelemetry;
+
+  getFinishReasonsList(): Array<string>;
+  setFinishReasonsList(value: Array<string>): LlmTelemetry;
+  clearFinishReasonsList(): LlmTelemetry;
+  addFinishReasons(value: string, index?: number): LlmTelemetry;
+
+  getCachedInputTokens(): number;
+  setCachedInputTokens(value: number): LlmTelemetry;
+
+  getCacheCreationInputTokens(): number;
+  setCacheCreationInputTokens(value: number): LlmTelemetry;
+
+  getLangsmithRunUrl(): string;
+  setLangsmithRunUrl(value: string): LlmTelemetry;
+
+  getTeamName(): string;
+  setTeamName(value: string): LlmTelemetry;
+
+  getTeamId(): string;
+  setTeamId(value: string): LlmTelemetry;
+
+  getAgentRole(): string;
+  setAgentRole(value: string): LlmTelemetry;
+
+  getSenderAgent(): string;
+  setSenderAgent(value: string): LlmTelemetry;
+
+  getRecipientAgent(): string;
+  setRecipientAgent(value: string): LlmTelemetry;
+
+  getTurnIndex(): number;
+  setTurnIndex(value: number): LlmTelemetry;
+
+  getReflectionIterations(): number;
+  setReflectionIterations(value: number): LlmTelemetry;
+
+  getTerminationReason(): string;
+  setTerminationReason(value: string): LlmTelemetry;
+
+  getEvaluatorRunsJoinKey(): string;
+  setEvaluatorRunsJoinKey(value: string): LlmTelemetry;
+
+  getLlmEvaluationFeedbacksList(): Array<ondewo_nlu_llm_evaluation_pb.LlmEvaluationFeedback>;
+  setLlmEvaluationFeedbacksList(value: Array<ondewo_nlu_llm_evaluation_pb.LlmEvaluationFeedback>): LlmTelemetry;
+  clearLlmEvaluationFeedbacksList(): LlmTelemetry;
+  addLlmEvaluationFeedbacks(value?: ondewo_nlu_llm_evaluation_pb.LlmEvaluationFeedback, index?: number): ondewo_nlu_llm_evaluation_pb.LlmEvaluationFeedback;
+
+  getCcaiServiceName(): string;
+  setCcaiServiceName(value: string): LlmTelemetry;
+
+  getBaseUrl(): string;
+  setBaseUrl(value: string): LlmTelemetry;
+
+  getDefaultHeaders(): google_protobuf_struct_pb.Struct | undefined;
+  setDefaultHeaders(value?: google_protobuf_struct_pb.Struct): LlmTelemetry;
+  hasDefaultHeaders(): boolean;
+  clearDefaultHeaders(): LlmTelemetry;
+
+  getDefaultQuery(): google_protobuf_struct_pb.Struct | undefined;
+  setDefaultQuery(value?: google_protobuf_struct_pb.Struct): LlmTelemetry;
+  hasDefaultQuery(): boolean;
+  clearDefaultQuery(): LlmTelemetry;
+
+  getFrequencyPenalty(): number;
+  setFrequencyPenalty(value: number): LlmTelemetry;
+  hasFrequencyPenalty(): boolean;
+  clearFrequencyPenalty(): LlmTelemetry;
+
+  getOpenaiMetadata(): google_protobuf_struct_pb.Struct | undefined;
+  setOpenaiMetadata(value?: google_protobuf_struct_pb.Struct): LlmTelemetry;
+  hasOpenaiMetadata(): boolean;
+  clearOpenaiMetadata(): LlmTelemetry;
+
+  getPresencePenalty(): number;
+  setPresencePenalty(value: number): LlmTelemetry;
+  hasPresencePenalty(): boolean;
+  clearPresencePenalty(): LlmTelemetry;
+
+  getReasoningEffort(): ReasoningEffort;
+  setReasoningEffort(value: ReasoningEffort): LlmTelemetry;
+  hasReasoningEffort(): boolean;
+  clearReasoningEffort(): LlmTelemetry;
+
+  getUser(): string;
+  setUser(value: string): LlmTelemetry;
+  hasUser(): boolean;
+  clearUser(): LlmTelemetry;
+
+  getTimeout(): number;
+  setTimeout(value: number): LlmTelemetry;
+  hasTimeout(): boolean;
+  clearTimeout(): LlmTelemetry;
+
+  getStrictResponseValidation(): boolean;
+  setStrictResponseValidation(value: boolean): LlmTelemetry;
+  hasStrictResponseValidation(): boolean;
+  clearStrictResponseValidation(): LlmTelemetry;
+
+  getExtraHeaders(): google_protobuf_struct_pb.Struct | undefined;
+  setExtraHeaders(value?: google_protobuf_struct_pb.Struct): LlmTelemetry;
+  hasExtraHeaders(): boolean;
+  clearExtraHeaders(): LlmTelemetry;
+
+  getExtraQuery(): google_protobuf_struct_pb.Struct | undefined;
+  setExtraQuery(value?: google_protobuf_struct_pb.Struct): LlmTelemetry;
+  hasExtraQuery(): boolean;
+  clearExtraQuery(): LlmTelemetry;
+
+  getExtraBody(): google_protobuf_struct_pb.Struct | undefined;
+  setExtraBody(value?: google_protobuf_struct_pb.Struct): LlmTelemetry;
+  hasExtraBody(): boolean;
+  clearExtraBody(): LlmTelemetry;
+
+  getCcaiServiceProvider(): ondewo_nlu_ccai_project_pb.CcaiServiceProvider;
+  setCcaiServiceProvider(value: ondewo_nlu_ccai_project_pb.CcaiServiceProvider): LlmTelemetry;
+
+  getLlmSafetyAssessment(): LlmSafetyAssessment | undefined;
+  setLlmSafetyAssessment(value?: LlmSafetyAssessment): LlmTelemetry;
+  hasLlmSafetyAssessment(): boolean;
+  clearLlmSafetyAssessment(): LlmTelemetry;
+
+  getLlmRetrievalMetadata(): LlmRetrievalMetadata | undefined;
+  setLlmRetrievalMetadata(value?: LlmRetrievalMetadata): LlmTelemetry;
+  hasLlmRetrievalMetadata(): boolean;
+  clearLlmRetrievalMetadata(): LlmTelemetry;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmTelemetry.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmTelemetry): LlmTelemetry.AsObject;
+  static serializeBinaryToWriter(message: LlmTelemetry, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmTelemetry;
+  static deserializeBinaryFromReader(message: LlmTelemetry, reader: jspb.BinaryReader): LlmTelemetry;
+}
+
+export namespace LlmTelemetry {
+  export type AsObject = {
+    provider: string,
+    modelName: string,
+    agentName: string,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+    llmToolCallMetadatasList: Array<LlmToolCallMetadata.AsObject>,
+    toolCallCount: number,
+    llmThinkingMetadata?: LlmThinkingMetadata.AsObject,
+    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    durationInS: number,
+    runId: string,
+    parentRunId: string,
+    runType: string,
+    componentName: string,
+    tagsList: Array<string>,
+    metadata?: google_protobuf_struct_pb.Struct.AsObject,
+    inputs?: google_protobuf_struct_pb.Struct.AsObject,
+    outputs?: google_protobuf_struct_pb.Struct.AsObject,
+    errorClass: string,
+    errorMessage: string,
+    traceback: string,
+    streamingChunkCount: number,
+    firstTokenLatencySeconds: number,
+    systemFingerprint: string,
+    cached: boolean,
+    retryCount: number,
+    fallbackDepth: number,
+    temperature: number,
+    topP: number,
+    maxTokens: number,
+    nGenerations: number,
+    finishReasonsList: Array<string>,
+    cachedInputTokens: number,
+    cacheCreationInputTokens: number,
+    langsmithRunUrl: string,
+    teamName: string,
+    teamId: string,
+    agentRole: string,
+    senderAgent: string,
+    recipientAgent: string,
+    turnIndex: number,
+    reflectionIterations: number,
+    terminationReason: string,
+    evaluatorRunsJoinKey: string,
+    llmEvaluationFeedbacksList: Array<ondewo_nlu_llm_evaluation_pb.LlmEvaluationFeedback.AsObject>,
+    ccaiServiceName: string,
+    baseUrl: string,
+    defaultHeaders?: google_protobuf_struct_pb.Struct.AsObject,
+    defaultQuery?: google_protobuf_struct_pb.Struct.AsObject,
+    frequencyPenalty?: number,
+    openaiMetadata?: google_protobuf_struct_pb.Struct.AsObject,
+    presencePenalty?: number,
+    reasoningEffort?: ReasoningEffort,
+    user?: string,
+    timeout?: number,
+    strictResponseValidation?: boolean,
+    extraHeaders?: google_protobuf_struct_pb.Struct.AsObject,
+    extraQuery?: google_protobuf_struct_pb.Struct.AsObject,
+    extraBody?: google_protobuf_struct_pb.Struct.AsObject,
+    ccaiServiceProvider: ondewo_nlu_ccai_project_pb.CcaiServiceProvider,
+    llmSafetyAssessment?: LlmSafetyAssessment.AsObject,
+    llmRetrievalMetadata?: LlmRetrievalMetadata.AsObject,
+  }
+
+  export enum DefaultHeadersCase { 
+    _DEFAULT_HEADERS_NOT_SET = 0,
+    DEFAULT_HEADERS = 48,
+  }
+
+  export enum DefaultQueryCase { 
+    _DEFAULT_QUERY_NOT_SET = 0,
+    DEFAULT_QUERY = 49,
+  }
+
+  export enum FrequencyPenaltyCase { 
+    _FREQUENCY_PENALTY_NOT_SET = 0,
+    FREQUENCY_PENALTY = 50,
+  }
+
+  export enum OpenaiMetadataCase { 
+    _OPENAI_METADATA_NOT_SET = 0,
+    OPENAI_METADATA = 51,
+  }
+
+  export enum PresencePenaltyCase { 
+    _PRESENCE_PENALTY_NOT_SET = 0,
+    PRESENCE_PENALTY = 52,
+  }
+
+  export enum ReasoningEffortCase { 
+    _REASONING_EFFORT_NOT_SET = 0,
+    REASONING_EFFORT = 53,
+  }
+
+  export enum UserCase { 
+    _USER_NOT_SET = 0,
+    USER = 54,
+  }
+
+  export enum TimeoutCase { 
+    _TIMEOUT_NOT_SET = 0,
+    TIMEOUT = 55,
+  }
+
+  export enum StrictResponseValidationCase { 
+    _STRICT_RESPONSE_VALIDATION_NOT_SET = 0,
+    STRICT_RESPONSE_VALIDATION = 56,
+  }
+
+  export enum ExtraHeadersCase { 
+    _EXTRA_HEADERS_NOT_SET = 0,
+    EXTRA_HEADERS = 57,
+  }
+
+  export enum ExtraQueryCase { 
+    _EXTRA_QUERY_NOT_SET = 0,
+    EXTRA_QUERY = 58,
+  }
+
+  export enum ExtraBodyCase { 
+    _EXTRA_BODY_NOT_SET = 0,
+    EXTRA_BODY = 59,
+  }
+}
+
+export class LlmSafetyFinding extends jspb.Message {
+  getCategory(): string;
+  setCategory(value: string): LlmSafetyFinding;
+
+  getSeverity(): string;
+  setSeverity(value: string): LlmSafetyFinding;
+
+  getMatchedPattern(): string;
+  setMatchedPattern(value: string): LlmSafetyFinding;
+
+  getLocation(): LlmSafetyLocation;
+  setLocation(value: LlmSafetyLocation): LlmSafetyFinding;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmSafetyFinding.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmSafetyFinding): LlmSafetyFinding.AsObject;
+  static serializeBinaryToWriter(message: LlmSafetyFinding, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmSafetyFinding;
+  static deserializeBinaryFromReader(message: LlmSafetyFinding, reader: jspb.BinaryReader): LlmSafetyFinding;
+}
+
+export namespace LlmSafetyFinding {
+  export type AsObject = {
+    category: string,
+    severity: string,
+    matchedPattern: string,
+    location: LlmSafetyLocation,
+  }
+}
+
+export class LlmSafetyAssessment extends jspb.Message {
+  getFlaggedCategoriesList(): Array<string>;
+  setFlaggedCategoriesList(value: Array<string>): LlmSafetyAssessment;
+  clearFlaggedCategoriesList(): LlmSafetyAssessment;
+  addFlaggedCategories(value: string, index?: number): LlmSafetyAssessment;
+
+  getHasPii(): boolean;
+  setHasPii(value: boolean): LlmSafetyAssessment;
+
+  getHasInjectionAttempt(): boolean;
+  setHasInjectionAttempt(value: boolean): LlmSafetyAssessment;
+
+  getHasJailbreakAttempt(): boolean;
+  setHasJailbreakAttempt(value: boolean): LlmSafetyAssessment;
+
+  getSafetyScore(): number;
+  setSafetyScore(value: number): LlmSafetyAssessment;
+
+  getFindingsList(): Array<LlmSafetyFinding>;
+  setFindingsList(value: Array<LlmSafetyFinding>): LlmSafetyAssessment;
+  clearFindingsList(): LlmSafetyAssessment;
+  addFindings(value?: LlmSafetyFinding, index?: number): LlmSafetyFinding;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmSafetyAssessment.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmSafetyAssessment): LlmSafetyAssessment.AsObject;
+  static serializeBinaryToWriter(message: LlmSafetyAssessment, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmSafetyAssessment;
+  static deserializeBinaryFromReader(message: LlmSafetyAssessment, reader: jspb.BinaryReader): LlmSafetyAssessment;
+}
+
+export namespace LlmSafetyAssessment {
+  export type AsObject = {
+    flaggedCategoriesList: Array<string>,
+    hasPii: boolean,
+    hasInjectionAttempt: boolean,
+    hasJailbreakAttempt: boolean,
+    safetyScore: number,
+    findingsList: Array<LlmSafetyFinding.AsObject>,
+  }
+}
+
+export class LlmRetrievedChunk extends jspb.Message {
+  getDocumentId(): string;
+  setDocumentId(value: string): LlmRetrievedChunk;
+
+  getChunkId(): string;
+  setChunkId(value: string): LlmRetrievedChunk;
+
+  getScore(): number;
+  setScore(value: number): LlmRetrievedChunk;
+
+  getText(): string;
+  setText(value: string): LlmRetrievedChunk;
+
+  getSourceUri(): string;
+  setSourceUri(value: string): LlmRetrievedChunk;
+
+  getRank(): number;
+  setRank(value: number): LlmRetrievedChunk;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmRetrievedChunk.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmRetrievedChunk): LlmRetrievedChunk.AsObject;
+  static serializeBinaryToWriter(message: LlmRetrievedChunk, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmRetrievedChunk;
+  static deserializeBinaryFromReader(message: LlmRetrievedChunk, reader: jspb.BinaryReader): LlmRetrievedChunk;
+}
+
+export namespace LlmRetrievedChunk {
+  export type AsObject = {
+    documentId: string,
+    chunkId: string,
+    score: number,
+    text: string,
+    sourceUri: string,
+    rank: number,
+  }
+}
+
+export class LlmRetrievalMetadata extends jspb.Message {
+  getChunksList(): Array<LlmRetrievedChunk>;
+  setChunksList(value: Array<LlmRetrievedChunk>): LlmRetrievalMetadata;
+  clearChunksList(): LlmRetrievalMetadata;
+  addChunks(value?: LlmRetrievedChunk, index?: number): LlmRetrievedChunk;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmRetrievalMetadata.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmRetrievalMetadata): LlmRetrievalMetadata.AsObject;
+  static serializeBinaryToWriter(message: LlmRetrievalMetadata, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmRetrievalMetadata;
+  static deserializeBinaryFromReader(message: LlmRetrievalMetadata, reader: jspb.BinaryReader): LlmRetrievalMetadata;
+}
+
+export namespace LlmRetrievalMetadata {
+  export type AsObject = {
+    chunksList: Array<LlmRetrievedChunk.AsObject>,
+  }
+}
+
+export class LlmLatencyStats extends jspb.Message {
+  getCallCount(): number;
+  setCallCount(value: number): LlmLatencyStats;
+
+  getMeanDurationSeconds(): number;
+  setMeanDurationSeconds(value: number): LlmLatencyStats;
+
+  getP50DurationSeconds(): number;
+  setP50DurationSeconds(value: number): LlmLatencyStats;
+
+  getP95DurationSeconds(): number;
+  setP95DurationSeconds(value: number): LlmLatencyStats;
+
+  getP99DurationSeconds(): number;
+  setP99DurationSeconds(value: number): LlmLatencyStats;
+
+  getMaxDurationSeconds(): number;
+  setMaxDurationSeconds(value: number): LlmLatencyStats;
+
+  getMeanFirstTokenLatencySeconds(): number;
+  setMeanFirstTokenLatencySeconds(value: number): LlmLatencyStats;
+
+  getP95FirstTokenLatencySeconds(): number;
+  setP95FirstTokenLatencySeconds(value: number): LlmLatencyStats;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmLatencyStats.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmLatencyStats): LlmLatencyStats.AsObject;
+  static serializeBinaryToWriter(message: LlmLatencyStats, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmLatencyStats;
+  static deserializeBinaryFromReader(message: LlmLatencyStats, reader: jspb.BinaryReader): LlmLatencyStats;
+}
+
+export namespace LlmLatencyStats {
+  export type AsObject = {
+    callCount: number,
+    meanDurationSeconds: number,
+    p50DurationSeconds: number,
+    p95DurationSeconds: number,
+    p99DurationSeconds: number,
+    maxDurationSeconds: number,
+    meanFirstTokenLatencySeconds: number,
+    p95FirstTokenLatencySeconds: number,
+  }
+}
+
+export class LlmCacheStats extends jspb.Message {
+  getCachedInputTokens(): number;
+  setCachedInputTokens(value: number): LlmCacheStats;
+
+  getCacheCreationInputTokens(): number;
+  setCacheCreationInputTokens(value: number): LlmCacheStats;
+
+  getUncachedInputTokens(): number;
+  setUncachedInputTokens(value: number): LlmCacheStats;
+
+  getCacheHitRate(): number;
+  setCacheHitRate(value: number): LlmCacheStats;
+
+  getTokenSavings(): number;
+  setTokenSavings(value: number): LlmCacheStats;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmCacheStats.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmCacheStats): LlmCacheStats.AsObject;
+  static serializeBinaryToWriter(message: LlmCacheStats, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmCacheStats;
+  static deserializeBinaryFromReader(message: LlmCacheStats, reader: jspb.BinaryReader): LlmCacheStats;
+}
+
+export namespace LlmCacheStats {
+  export type AsObject = {
+    cachedInputTokens: number,
+    cacheCreationInputTokens: number,
+    uncachedInputTokens: number,
+    cacheHitRate: number,
+    tokenSavings: number,
+  }
+}
+
+export class LlmModelUsage extends jspb.Message {
+  getModelName(): string;
+  setModelName(value: string): LlmModelUsage;
+
+  getProvider(): string;
+  setProvider(value: string): LlmModelUsage;
+
+  getCallCount(): number;
+  setCallCount(value: number): LlmModelUsage;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmModelUsage;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmModelUsage;
+
+  getToolCallCount(): number;
+  setToolCallCount(value: number): LlmModelUsage;
+
+  getErrorCount(): number;
+  setErrorCount(value: number): LlmModelUsage;
+
+  getDurationSecondsTotal(): number;
+  setDurationSecondsTotal(value: number): LlmModelUsage;
+
+  getCacheStats(): LlmCacheStats | undefined;
+  setCacheStats(value?: LlmCacheStats): LlmModelUsage;
+  hasCacheStats(): boolean;
+  clearCacheStats(): LlmModelUsage;
+
+  getCcaiServiceName(): string;
+  setCcaiServiceName(value: string): LlmModelUsage;
+
+  getCcaiServiceProvider(): ondewo_nlu_ccai_project_pb.CcaiServiceProvider;
+  setCcaiServiceProvider(value: ondewo_nlu_ccai_project_pb.CcaiServiceProvider): LlmModelUsage;
+
+  getBaseUrl(): string;
+  setBaseUrl(value: string): LlmModelUsage;
+
+  getThinkingTokensTotal(): number;
+  setThinkingTokensTotal(value: number): LlmModelUsage;
+
+  getThinkingDurationSecondsTotal(): number;
+  setThinkingDurationSecondsTotal(value: number): LlmModelUsage;
+
+  getToolCallTokensTotal(): number;
+  setToolCallTokensTotal(value: number): LlmModelUsage;
+
+  getToolCallDurationSecondsTotal(): number;
+  setToolCallDurationSecondsTotal(value: number): LlmModelUsage;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmModelUsage.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmModelUsage): LlmModelUsage.AsObject;
+  static serializeBinaryToWriter(message: LlmModelUsage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmModelUsage;
+  static deserializeBinaryFromReader(message: LlmModelUsage, reader: jspb.BinaryReader): LlmModelUsage;
+}
+
+export namespace LlmModelUsage {
+  export type AsObject = {
+    modelName: string,
+    provider: string,
+    callCount: number,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+    toolCallCount: number,
+    errorCount: number,
+    durationSecondsTotal: number,
+    cacheStats?: LlmCacheStats.AsObject,
+    ccaiServiceName: string,
+    ccaiServiceProvider: ondewo_nlu_ccai_project_pb.CcaiServiceProvider,
+    baseUrl: string,
+    thinkingTokensTotal: number,
+    thinkingDurationSecondsTotal: number,
+    toolCallTokensTotal: number,
+    toolCallDurationSecondsTotal: number,
+  }
+}
+
+export class LlmProviderUsage extends jspb.Message {
+  getProvider(): string;
+  setProvider(value: string): LlmProviderUsage;
+
+  getCallCount(): number;
+  setCallCount(value: number): LlmProviderUsage;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmProviderUsage;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmProviderUsage;
+
+  getErrorCount(): number;
+  setErrorCount(value: number): LlmProviderUsage;
+
+  getDurationSecondsTotal(): number;
+  setDurationSecondsTotal(value: number): LlmProviderUsage;
+
+  getModelNamesList(): Array<string>;
+  setModelNamesList(value: Array<string>): LlmProviderUsage;
+  clearModelNamesList(): LlmProviderUsage;
+  addModelNames(value: string, index?: number): LlmProviderUsage;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmProviderUsage.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmProviderUsage): LlmProviderUsage.AsObject;
+  static serializeBinaryToWriter(message: LlmProviderUsage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmProviderUsage;
+  static deserializeBinaryFromReader(message: LlmProviderUsage, reader: jspb.BinaryReader): LlmProviderUsage;
+}
+
+export namespace LlmProviderUsage {
+  export type AsObject = {
+    provider: string,
+    callCount: number,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+    errorCount: number,
+    durationSecondsTotal: number,
+    modelNamesList: Array<string>,
+  }
+}
+
+export class LlmCcaiServiceUsage extends jspb.Message {
+  getCcaiServiceProvider(): ondewo_nlu_ccai_project_pb.CcaiServiceProvider;
+  setCcaiServiceProvider(value: ondewo_nlu_ccai_project_pb.CcaiServiceProvider): LlmCcaiServiceUsage;
+
+  getCcaiServiceName(): string;
+  setCcaiServiceName(value: string): LlmCcaiServiceUsage;
+
+  getCallCount(): number;
+  setCallCount(value: number): LlmCcaiServiceUsage;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmCcaiServiceUsage;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmCcaiServiceUsage;
+
+  getBaseUrl(): string;
+  setBaseUrl(value: string): LlmCcaiServiceUsage;
+
+  getModelNamesList(): Array<string>;
+  setModelNamesList(value: Array<string>): LlmCcaiServiceUsage;
+  clearModelNamesList(): LlmCcaiServiceUsage;
+  addModelNames(value: string, index?: number): LlmCcaiServiceUsage;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmCcaiServiceUsage.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmCcaiServiceUsage): LlmCcaiServiceUsage.AsObject;
+  static serializeBinaryToWriter(message: LlmCcaiServiceUsage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmCcaiServiceUsage;
+  static deserializeBinaryFromReader(message: LlmCcaiServiceUsage, reader: jspb.BinaryReader): LlmCcaiServiceUsage;
+}
+
+export namespace LlmCcaiServiceUsage {
+  export type AsObject = {
+    ccaiServiceProvider: ondewo_nlu_ccai_project_pb.CcaiServiceProvider,
+    ccaiServiceName: string,
+    callCount: number,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+    baseUrl: string,
+    modelNamesList: Array<string>,
+  }
+}
+
+export class LlmAgentUsage extends jspb.Message {
+  getAgentName(): string;
+  setAgentName(value: string): LlmAgentUsage;
+
+  getAgentRole(): string;
+  setAgentRole(value: string): LlmAgentUsage;
+
+  getTeamName(): string;
+  setTeamName(value: string): LlmAgentUsage;
+
+  getCallCount(): number;
+  setCallCount(value: number): LlmAgentUsage;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmAgentUsage;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmAgentUsage;
+
+  getToolCallCount(): number;
+  setToolCallCount(value: number): LlmAgentUsage;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmAgentUsage.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmAgentUsage): LlmAgentUsage.AsObject;
+  static serializeBinaryToWriter(message: LlmAgentUsage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmAgentUsage;
+  static deserializeBinaryFromReader(message: LlmAgentUsage, reader: jspb.BinaryReader): LlmAgentUsage;
+}
+
+export namespace LlmAgentUsage {
+  export type AsObject = {
+    agentName: string,
+    agentRole: string,
+    teamName: string,
+    callCount: number,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+    toolCallCount: number,
+  }
+}
+
+export class LlmToolUsage extends jspb.Message {
+  getToolName(): string;
+  setToolName(value: string): LlmToolUsage;
+
+  getCallCount(): number;
+  setCallCount(value: number): LlmToolUsage;
+
+  getErrorCount(): number;
+  setErrorCount(value: number): LlmToolUsage;
+
+  getErrorRate(): number;
+  setErrorRate(value: number): LlmToolUsage;
+
+  getDurationSecondsTotal(): number;
+  setDurationSecondsTotal(value: number): LlmToolUsage;
+
+  getMeanDurationSeconds(): number;
+  setMeanDurationSeconds(value: number): LlmToolUsage;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmToolUsage;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmToolUsage;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmToolUsage.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmToolUsage): LlmToolUsage.AsObject;
+  static serializeBinaryToWriter(message: LlmToolUsage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmToolUsage;
+  static deserializeBinaryFromReader(message: LlmToolUsage, reader: jspb.BinaryReader): LlmToolUsage;
+}
+
+export namespace LlmToolUsage {
+  export type AsObject = {
+    toolName: string,
+    callCount: number,
+    errorCount: number,
+    errorRate: number,
+    durationSecondsTotal: number,
+    meanDurationSeconds: number,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+  }
+}
+
+export class LlmErrorStat extends jspb.Message {
+  getErrorClass(): string;
+  setErrorClass(value: string): LlmErrorStat;
+
+  getCount(): number;
+  setCount(value: number): LlmErrorStat;
+
+  getRate(): number;
+  setRate(value: number): LlmErrorStat;
+
+  getSampleMessage(): string;
+  setSampleMessage(value: string): LlmErrorStat;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmErrorStat.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmErrorStat): LlmErrorStat.AsObject;
+  static serializeBinaryToWriter(message: LlmErrorStat, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmErrorStat;
+  static deserializeBinaryFromReader(message: LlmErrorStat, reader: jspb.BinaryReader): LlmErrorStat;
+}
+
+export namespace LlmErrorStat {
+  export type AsObject = {
+    errorClass: string,
+    count: number,
+    rate: number,
+    sampleMessage: string,
+  }
+}
+
+export class LlmErrorStats extends jspb.Message {
+  getTotalErrorCount(): number;
+  setTotalErrorCount(value: number): LlmErrorStats;
+
+  getOverallErrorRate(): number;
+  setOverallErrorRate(value: number): LlmErrorStats;
+
+  getErrorsByClassList(): Array<LlmErrorStat>;
+  setErrorsByClassList(value: Array<LlmErrorStat>): LlmErrorStats;
+  clearErrorsByClassList(): LlmErrorStats;
+  addErrorsByClass(value?: LlmErrorStat, index?: number): LlmErrorStat;
+
+  getRetryCountTotal(): number;
+  setRetryCountTotal(value: number): LlmErrorStats;
+
+  getMaxFallbackDepth(): number;
+  setMaxFallbackDepth(value: number): LlmErrorStats;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmErrorStats.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmErrorStats): LlmErrorStats.AsObject;
+  static serializeBinaryToWriter(message: LlmErrorStats, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmErrorStats;
+  static deserializeBinaryFromReader(message: LlmErrorStats, reader: jspb.BinaryReader): LlmErrorStats;
+}
+
+export namespace LlmErrorStats {
+  export type AsObject = {
+    totalErrorCount: number,
+    overallErrorRate: number,
+    errorsByClassList: Array<LlmErrorStat.AsObject>,
+    retryCountTotal: number,
+    maxFallbackDepth: number,
+  }
+}
+
+export class LlmFinishReasonStat extends jspb.Message {
+  getFinishReason(): string;
+  setFinishReason(value: string): LlmFinishReasonStat;
+
+  getCount(): number;
+  setCount(value: number): LlmFinishReasonStat;
+
+  getRate(): number;
+  setRate(value: number): LlmFinishReasonStat;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmFinishReasonStat.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmFinishReasonStat): LlmFinishReasonStat.AsObject;
+  static serializeBinaryToWriter(message: LlmFinishReasonStat, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmFinishReasonStat;
+  static deserializeBinaryFromReader(message: LlmFinishReasonStat, reader: jspb.BinaryReader): LlmFinishReasonStat;
+}
+
+export namespace LlmFinishReasonStat {
+  export type AsObject = {
+    finishReason: string,
+    count: number,
+    rate: number,
+  }
+}
+
+export class LlmReasoningEffortStat extends jspb.Message {
+  getReasoningEffort(): ReasoningEffort;
+  setReasoningEffort(value: ReasoningEffort): LlmReasoningEffortStat;
+
+  getCount(): number;
+  setCount(value: number): LlmReasoningEffortStat;
+
+  getRate(): number;
+  setRate(value: number): LlmReasoningEffortStat;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmReasoningEffortStat;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmReasoningEffortStat;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmReasoningEffortStat.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmReasoningEffortStat): LlmReasoningEffortStat.AsObject;
+  static serializeBinaryToWriter(message: LlmReasoningEffortStat, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmReasoningEffortStat;
+  static deserializeBinaryFromReader(message: LlmReasoningEffortStat, reader: jspb.BinaryReader): LlmReasoningEffortStat;
+}
+
+export namespace LlmReasoningEffortStat {
+  export type AsObject = {
+    reasoningEffort: ReasoningEffort,
+    count: number,
+    rate: number,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+  }
+}
+
+export class LlmTelemetryReport extends jspb.Message {
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmTelemetryReport;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmTelemetryReport;
+
+  getToolCallCountTotal(): number;
+  setToolCallCountTotal(value: number): LlmTelemetryReport;
+
+  getLlmCallCount(): number;
+  setLlmCallCount(value: number): LlmTelemetryReport;
+
+  getLlmTelemetriesList(): Array<LlmTelemetry>;
+  setLlmTelemetriesList(value: Array<LlmTelemetry>): LlmTelemetryReport;
+  clearLlmTelemetriesList(): LlmTelemetryReport;
+  addLlmTelemetries(value?: LlmTelemetry, index?: number): LlmTelemetry;
+
+  getDurationSecondsTotal(): number;
+  setDurationSecondsTotal(value: number): LlmTelemetryReport;
+
+  getModelsUsedList(): Array<LlmModelUsage>;
+  setModelsUsedList(value: Array<LlmModelUsage>): LlmTelemetryReport;
+  clearModelsUsedList(): LlmTelemetryReport;
+  addModelsUsed(value?: LlmModelUsage, index?: number): LlmModelUsage;
+
+  getProvidersUsedList(): Array<LlmProviderUsage>;
+  setProvidersUsedList(value: Array<LlmProviderUsage>): LlmTelemetryReport;
+  clearProvidersUsedList(): LlmTelemetryReport;
+  addProvidersUsed(value?: LlmProviderUsage, index?: number): LlmProviderUsage;
+
+  getCcaiServicesUsedList(): Array<LlmCcaiServiceUsage>;
+  setCcaiServicesUsedList(value: Array<LlmCcaiServiceUsage>): LlmTelemetryReport;
+  clearCcaiServicesUsedList(): LlmTelemetryReport;
+  addCcaiServicesUsed(value?: LlmCcaiServiceUsage, index?: number): LlmCcaiServiceUsage;
+
+  getAgentsUsedList(): Array<LlmAgentUsage>;
+  setAgentsUsedList(value: Array<LlmAgentUsage>): LlmTelemetryReport;
+  clearAgentsUsedList(): LlmTelemetryReport;
+  addAgentsUsed(value?: LlmAgentUsage, index?: number): LlmAgentUsage;
+
+  getToolsUsedList(): Array<LlmToolUsage>;
+  setToolsUsedList(value: Array<LlmToolUsage>): LlmTelemetryReport;
+  clearToolsUsedList(): LlmTelemetryReport;
+  addToolsUsed(value?: LlmToolUsage, index?: number): LlmToolUsage;
+
+  getLatencyStats(): LlmLatencyStats | undefined;
+  setLatencyStats(value?: LlmLatencyStats): LlmTelemetryReport;
+  hasLatencyStats(): boolean;
+  clearLatencyStats(): LlmTelemetryReport;
+
+  getCacheStats(): LlmCacheStats | undefined;
+  setCacheStats(value?: LlmCacheStats): LlmTelemetryReport;
+  hasCacheStats(): boolean;
+  clearCacheStats(): LlmTelemetryReport;
+
+  getErrorStats(): LlmErrorStats | undefined;
+  setErrorStats(value?: LlmErrorStats): LlmTelemetryReport;
+  hasErrorStats(): boolean;
+  clearErrorStats(): LlmTelemetryReport;
+
+  getFinishReasonDistributionList(): Array<LlmFinishReasonStat>;
+  setFinishReasonDistributionList(value: Array<LlmFinishReasonStat>): LlmTelemetryReport;
+  clearFinishReasonDistributionList(): LlmTelemetryReport;
+  addFinishReasonDistribution(value?: LlmFinishReasonStat, index?: number): LlmFinishReasonStat;
+
+  getReasoningEffortDistributionList(): Array<LlmReasoningEffortStat>;
+  setReasoningEffortDistributionList(value: Array<LlmReasoningEffortStat>): LlmTelemetryReport;
+  clearReasoningEffortDistributionList(): LlmTelemetryReport;
+  addReasoningEffortDistribution(value?: LlmReasoningEffortStat, index?: number): LlmReasoningEffortStat;
+
+  getThinkingTokensTotal(): number;
+  setThinkingTokensTotal(value: number): LlmTelemetryReport;
+
+  getThinkingDurationSecondsTotal(): number;
+  setThinkingDurationSecondsTotal(value: number): LlmTelemetryReport;
+
+  getToolCallTokensTotal(): number;
+  setToolCallTokensTotal(value: number): LlmTelemetryReport;
+
+  getToolCallDurationSecondsTotal(): number;
+  setToolCallDurationSecondsTotal(value: number): LlmTelemetryReport;
+
+  getSafetyStats(): LlmSafetyStats | undefined;
+  setSafetyStats(value?: LlmSafetyStats): LlmTelemetryReport;
+  hasSafetyStats(): boolean;
+  clearSafetyStats(): LlmTelemetryReport;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmTelemetryReport.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmTelemetryReport): LlmTelemetryReport.AsObject;
+  static serializeBinaryToWriter(message: LlmTelemetryReport, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmTelemetryReport;
+  static deserializeBinaryFromReader(message: LlmTelemetryReport, reader: jspb.BinaryReader): LlmTelemetryReport;
+}
+
+export namespace LlmTelemetryReport {
+  export type AsObject = {
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+    toolCallCountTotal: number,
+    llmCallCount: number,
+    llmTelemetriesList: Array<LlmTelemetry.AsObject>,
+    durationSecondsTotal: number,
+    modelsUsedList: Array<LlmModelUsage.AsObject>,
+    providersUsedList: Array<LlmProviderUsage.AsObject>,
+    ccaiServicesUsedList: Array<LlmCcaiServiceUsage.AsObject>,
+    agentsUsedList: Array<LlmAgentUsage.AsObject>,
+    toolsUsedList: Array<LlmToolUsage.AsObject>,
+    latencyStats?: LlmLatencyStats.AsObject,
+    cacheStats?: LlmCacheStats.AsObject,
+    errorStats?: LlmErrorStats.AsObject,
+    finishReasonDistributionList: Array<LlmFinishReasonStat.AsObject>,
+    reasoningEffortDistributionList: Array<LlmReasoningEffortStat.AsObject>,
+    thinkingTokensTotal: number,
+    thinkingDurationSecondsTotal: number,
+    toolCallTokensTotal: number,
+    toolCallDurationSecondsTotal: number,
+    safetyStats?: LlmSafetyStats.AsObject,
+  }
+}
+
+export class LlmSafetyCategoryStat extends jspb.Message {
+  getCategory(): string;
+  setCategory(value: string): LlmSafetyCategoryStat;
+
+  getCount(): number;
+  setCount(value: number): LlmSafetyCategoryStat;
+
+  getRate(): number;
+  setRate(value: number): LlmSafetyCategoryStat;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmSafetyCategoryStat.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmSafetyCategoryStat): LlmSafetyCategoryStat.AsObject;
+  static serializeBinaryToWriter(message: LlmSafetyCategoryStat, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmSafetyCategoryStat;
+  static deserializeBinaryFromReader(message: LlmSafetyCategoryStat, reader: jspb.BinaryReader): LlmSafetyCategoryStat;
+}
+
+export namespace LlmSafetyCategoryStat {
+  export type AsObject = {
+    category: string,
+    count: number,
+    rate: number,
+  }
+}
+
+export class LlmSafetyStats extends jspb.Message {
+  getTotalAssessed(): number;
+  setTotalAssessed(value: number): LlmSafetyStats;
+
+  getFlaggedCount(): number;
+  setFlaggedCount(value: number): LlmSafetyStats;
+
+  getOverallSafetyScore(): number;
+  setOverallSafetyScore(value: number): LlmSafetyStats;
+
+  getCategoryStatsList(): Array<LlmSafetyCategoryStat>;
+  setCategoryStatsList(value: Array<LlmSafetyCategoryStat>): LlmSafetyStats;
+  clearCategoryStatsList(): LlmSafetyStats;
+  addCategoryStats(value?: LlmSafetyCategoryStat, index?: number): LlmSafetyCategoryStat;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmSafetyStats.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmSafetyStats): LlmSafetyStats.AsObject;
+  static serializeBinaryToWriter(message: LlmSafetyStats, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmSafetyStats;
+  static deserializeBinaryFromReader(message: LlmSafetyStats, reader: jspb.BinaryReader): LlmSafetyStats;
+}
+
+export namespace LlmSafetyStats {
+  export type AsObject = {
+    totalAssessed: number,
+    flaggedCount: number,
+    overallSafetyScore: number,
+    categoryStatsList: Array<LlmSafetyCategoryStat.AsObject>,
+  }
+}
+
+export class LlmCallStartedEvent extends jspb.Message {
+  getLlmCallId(): string;
+  setLlmCallId(value: string): LlmCallStartedEvent;
+
+  getProvider(): string;
+  setProvider(value: string): LlmCallStartedEvent;
+
+  getModelName(): string;
+  setModelName(value: string): LlmCallStartedEvent;
+
+  getAgentName(): string;
+  setAgentName(value: string): LlmCallStartedEvent;
+
+  getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): LlmCallStartedEvent;
+  hasStartTime(): boolean;
+  clearStartTime(): LlmCallStartedEvent;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmCallStartedEvent.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmCallStartedEvent): LlmCallStartedEvent.AsObject;
+  static serializeBinaryToWriter(message: LlmCallStartedEvent, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmCallStartedEvent;
+  static deserializeBinaryFromReader(message: LlmCallStartedEvent, reader: jspb.BinaryReader): LlmCallStartedEvent;
+}
+
+export namespace LlmCallStartedEvent {
+  export type AsObject = {
+    llmCallId: string,
+    provider: string,
+    modelName: string,
+    agentName: string,
+    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+  }
+}
+
+export class LlmCallFinishedEvent extends jspb.Message {
+  getLlmCallId(): string;
+  setLlmCallId(value: string): LlmCallFinishedEvent;
+
+  getEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setEndTime(value?: google_protobuf_timestamp_pb.Timestamp): LlmCallFinishedEvent;
+  hasEndTime(): boolean;
+  clearEndTime(): LlmCallFinishedEvent;
+
+  getDurationInS(): number;
+  setDurationInS(value: number): LlmCallFinishedEvent;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmCallFinishedEvent;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmCallFinishedEvent;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmCallFinishedEvent.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmCallFinishedEvent): LlmCallFinishedEvent.AsObject;
+  static serializeBinaryToWriter(message: LlmCallFinishedEvent, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmCallFinishedEvent;
+  static deserializeBinaryFromReader(message: LlmCallFinishedEvent, reader: jspb.BinaryReader): LlmCallFinishedEvent;
+}
+
+export namespace LlmCallFinishedEvent {
+  export type AsObject = {
+    llmCallId: string,
+    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    durationInS: number,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+  }
+}
+
+export class LlmToolCallStartedEvent extends jspb.Message {
+  getToolCallId(): string;
+  setToolCallId(value: string): LlmToolCallStartedEvent;
+
+  getToolName(): string;
+  setToolName(value: string): LlmToolCallStartedEvent;
+
+  getArguments(): google_protobuf_struct_pb.Struct | undefined;
+  setArguments(value?: google_protobuf_struct_pb.Struct): LlmToolCallStartedEvent;
+  hasArguments(): boolean;
+  clearArguments(): LlmToolCallStartedEvent;
+
+  getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): LlmToolCallStartedEvent;
+  hasStartTime(): boolean;
+  clearStartTime(): LlmToolCallStartedEvent;
+
+  getLlmCallId(): string;
+  setLlmCallId(value: string): LlmToolCallStartedEvent;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmToolCallStartedEvent.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmToolCallStartedEvent): LlmToolCallStartedEvent.AsObject;
+  static serializeBinaryToWriter(message: LlmToolCallStartedEvent, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmToolCallStartedEvent;
+  static deserializeBinaryFromReader(message: LlmToolCallStartedEvent, reader: jspb.BinaryReader): LlmToolCallStartedEvent;
+}
+
+export namespace LlmToolCallStartedEvent {
+  export type AsObject = {
+    toolCallId: string,
+    toolName: string,
+    arguments?: google_protobuf_struct_pb.Struct.AsObject,
+    startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    llmCallId: string,
+  }
+}
+
+export class LlmToolCallFinishedEvent extends jspb.Message {
+  getToolCallId(): string;
+  setToolCallId(value: string): LlmToolCallFinishedEvent;
+
+  getEndTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setEndTime(value?: google_protobuf_timestamp_pb.Timestamp): LlmToolCallFinishedEvent;
+  hasEndTime(): boolean;
+  clearEndTime(): LlmToolCallFinishedEvent;
+
+  getDurationInS(): number;
+  setDurationInS(value: number): LlmToolCallFinishedEvent;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmToolCallFinishedEvent;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmToolCallFinishedEvent;
+
+  getResult(): google_protobuf_struct_pb.Struct | undefined;
+  setResult(value?: google_protobuf_struct_pb.Struct): LlmToolCallFinishedEvent;
+  hasResult(): boolean;
+  clearResult(): LlmToolCallFinishedEvent;
+
+  getErrorMessage(): string;
+  setErrorMessage(value: string): LlmToolCallFinishedEvent;
+
+  getLlmCallId(): string;
+  setLlmCallId(value: string): LlmToolCallFinishedEvent;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmToolCallFinishedEvent.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmToolCallFinishedEvent): LlmToolCallFinishedEvent.AsObject;
+  static serializeBinaryToWriter(message: LlmToolCallFinishedEvent, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmToolCallFinishedEvent;
+  static deserializeBinaryFromReader(message: LlmToolCallFinishedEvent, reader: jspb.BinaryReader): LlmToolCallFinishedEvent;
+}
+
+export namespace LlmToolCallFinishedEvent {
+  export type AsObject = {
+    toolCallId: string,
+    endTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    durationInS: number,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+    result?: google_protobuf_struct_pb.Struct.AsObject,
+    errorMessage: string,
+    llmCallId: string,
+  }
+}
+
+export class LlmThinkingDeltaEvent extends jspb.Message {
+  getLlmCallId(): string;
+  setLlmCallId(value: string): LlmThinkingDeltaEvent;
+
+  getTextDelta(): string;
+  setTextDelta(value: string): LlmThinkingDeltaEvent;
+
+  getTimestamp(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setTimestamp(value?: google_protobuf_timestamp_pb.Timestamp): LlmThinkingDeltaEvent;
+  hasTimestamp(): boolean;
+  clearTimestamp(): LlmThinkingDeltaEvent;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmThinkingDeltaEvent.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmThinkingDeltaEvent): LlmThinkingDeltaEvent.AsObject;
+  static serializeBinaryToWriter(message: LlmThinkingDeltaEvent, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmThinkingDeltaEvent;
+  static deserializeBinaryFromReader(message: LlmThinkingDeltaEvent, reader: jspb.BinaryReader): LlmThinkingDeltaEvent;
+}
+
+export namespace LlmThinkingDeltaEvent {
+  export type AsObject = {
+    llmCallId: string,
+    textDelta: string,
+    timestamp?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+  }
+}
+
+export class LlmTokenUsageUpdateEvent extends jspb.Message {
+  getLlmCallId(): string;
+  setLlmCallId(value: string): LlmTokenUsageUpdateEvent;
+
+  getLlmTokenUsage(): LlmTokenUsage | undefined;
+  setLlmTokenUsage(value?: LlmTokenUsage): LlmTokenUsageUpdateEvent;
+  hasLlmTokenUsage(): boolean;
+  clearLlmTokenUsage(): LlmTokenUsageUpdateEvent;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): LlmTokenUsageUpdateEvent.AsObject;
+  static toObject(includeInstance: boolean, msg: LlmTokenUsageUpdateEvent): LlmTokenUsageUpdateEvent.AsObject;
+  static serializeBinaryToWriter(message: LlmTokenUsageUpdateEvent, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): LlmTokenUsageUpdateEvent;
+  static deserializeBinaryFromReader(message: LlmTokenUsageUpdateEvent, reader: jspb.BinaryReader): LlmTokenUsageUpdateEvent;
+}
+
+export namespace LlmTokenUsageUpdateEvent {
+  export type AsObject = {
+    llmCallId: string,
+    llmTokenUsage?: LlmTokenUsage.AsObject,
+  }
+}
+
 export class QueryResult extends jspb.Message {
   getQueryText(): string;
   setQueryText(value: string): QueryResult;
@@ -333,6 +1805,11 @@ export class QueryResult extends jspb.Message {
   clearFileResourcesList(): QueryResult;
   addFileResources(value?: FileResource, index?: number): FileResource;
 
+  getLlmTelemetryReport(): LlmTelemetryReport | undefined;
+  setLlmTelemetryReport(value?: LlmTelemetryReport): QueryResult;
+  hasLlmTelemetryReport(): boolean;
+  clearLlmTelemetryReport(): QueryResult;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): QueryResult.AsObject;
   static toObject(includeInstance: boolean, msg: QueryResult): QueryResult.AsObject;
@@ -359,6 +1836,7 @@ export namespace QueryResult {
     diagnosticInfo?: google_protobuf_struct_pb.Struct.AsObject,
     languageCode: string,
     fileResourcesList: Array<FileResource.AsObject>,
+    llmTelemetryReport?: LlmTelemetryReport.AsObject,
   }
 }
 
@@ -421,6 +1899,38 @@ export class StreamingDetectIntentResponse extends jspb.Message {
   hasWebhookStatus(): boolean;
   clearWebhookStatus(): StreamingDetectIntentResponse;
 
+  getLlmCallStarted(): LlmCallStartedEvent | undefined;
+  setLlmCallStarted(value?: LlmCallStartedEvent): StreamingDetectIntentResponse;
+  hasLlmCallStarted(): boolean;
+  clearLlmCallStarted(): StreamingDetectIntentResponse;
+
+  getLlmCallFinished(): LlmCallFinishedEvent | undefined;
+  setLlmCallFinished(value?: LlmCallFinishedEvent): StreamingDetectIntentResponse;
+  hasLlmCallFinished(): boolean;
+  clearLlmCallFinished(): StreamingDetectIntentResponse;
+
+  getLlmToolCallStarted(): LlmToolCallStartedEvent | undefined;
+  setLlmToolCallStarted(value?: LlmToolCallStartedEvent): StreamingDetectIntentResponse;
+  hasLlmToolCallStarted(): boolean;
+  clearLlmToolCallStarted(): StreamingDetectIntentResponse;
+
+  getLlmToolCallFinished(): LlmToolCallFinishedEvent | undefined;
+  setLlmToolCallFinished(value?: LlmToolCallFinishedEvent): StreamingDetectIntentResponse;
+  hasLlmToolCallFinished(): boolean;
+  clearLlmToolCallFinished(): StreamingDetectIntentResponse;
+
+  getLlmThinkingDelta(): LlmThinkingDeltaEvent | undefined;
+  setLlmThinkingDelta(value?: LlmThinkingDeltaEvent): StreamingDetectIntentResponse;
+  hasLlmThinkingDelta(): boolean;
+  clearLlmThinkingDelta(): StreamingDetectIntentResponse;
+
+  getLlmTokenUsageUpdate(): LlmTokenUsageUpdateEvent | undefined;
+  setLlmTokenUsageUpdate(value?: LlmTokenUsageUpdateEvent): StreamingDetectIntentResponse;
+  hasLlmTokenUsageUpdate(): boolean;
+  clearLlmTokenUsageUpdate(): StreamingDetectIntentResponse;
+
+  getTelemetryEventCase(): StreamingDetectIntentResponse.TelemetryEventCase;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): StreamingDetectIntentResponse.AsObject;
   static toObject(includeInstance: boolean, msg: StreamingDetectIntentResponse): StreamingDetectIntentResponse.AsObject;
@@ -435,6 +1945,22 @@ export namespace StreamingDetectIntentResponse {
     recognitionResult?: StreamingRecognitionResult.AsObject,
     queryResult?: QueryResult.AsObject,
     webhookStatus?: google_rpc_status_pb.Status.AsObject,
+    llmCallStarted?: LlmCallStartedEvent.AsObject,
+    llmCallFinished?: LlmCallFinishedEvent.AsObject,
+    llmToolCallStarted?: LlmToolCallStartedEvent.AsObject,
+    llmToolCallFinished?: LlmToolCallFinishedEvent.AsObject,
+    llmThinkingDelta?: LlmThinkingDeltaEvent.AsObject,
+    llmTokenUsageUpdate?: LlmTokenUsageUpdateEvent.AsObject,
+  }
+
+  export enum TelemetryEventCase { 
+    TELEMETRY_EVENT_NOT_SET = 0,
+    LLM_CALL_STARTED = 5,
+    LLM_CALL_FINISHED = 6,
+    LLM_TOOL_CALL_STARTED = 7,
+    LLM_TOOL_CALL_FINISHED = 8,
+    LLM_THINKING_DELTA = 9,
+    LLM_TOKEN_USAGE_UPDATE = 10,
   }
 }
 
@@ -657,6 +2183,11 @@ export class SessionStep extends jspb.Message {
   clearAudioFileResourcesList(): SessionStep;
   addAudioFileResources(value?: AudioFileResource, index?: number): AudioFileResource;
 
+  getLlmTelemetryReport(): LlmTelemetryReport | undefined;
+  setLlmTelemetryReport(value?: LlmTelemetryReport): SessionStep;
+  hasLlmTelemetryReport(): boolean;
+  clearLlmTelemetryReport(): SessionStep;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): SessionStep.AsObject;
   static toObject(includeInstance: boolean, msg: SessionStep): SessionStep.AsObject;
@@ -677,6 +2208,7 @@ export namespace SessionStep {
     createdBy: string,
     modifiedBy: string,
     audioFileResourcesList: Array<AudioFileResource.AsObject>,
+    llmTelemetryReport?: LlmTelemetryReport.AsObject,
   }
 }
 
@@ -3228,6 +4760,18 @@ export enum TranscriptionType {
   TRANSCRIPTION_TYPE_S2T = 1,
   TRANSCRIPTION_TYPE_HUMAN = 2,
 }
+export enum ReasoningEffort { 
+  REASONING_EFFORT_UNSPECIFIED = 0,
+  REASONING_EFFORT_MINIMAL = 1,
+  REASONING_EFFORT_LOW = 2,
+  REASONING_EFFORT_MEDIUM = 3,
+  REASONING_EFFORT_HIGH = 4,
+}
+export enum LlmSafetyLocation { 
+  LLM_SAFETY_LOCATION_UNSPECIFIED = 0,
+  LLM_SAFETY_LOCATION_INPUT = 1,
+  LLM_SAFETY_LOCATION_OUTPUT = 2,
+}
 export enum AudioEncoding { 
   AUDIO_ENCODING_UNSPECIFIED = 0,
   AUDIO_ENCODING_LINEAR_16 = 1,