diff --git a/eslint.config.js b/eslint.config.js index 99b1b28f4b..dc05e6ab42 100644 --- a/eslint.config.js +++ b/eslint.config.js @@ -52,6 +52,7 @@ export default tseslint.config( 'packages/test-utils/**', '.gemini/skills/**', '**/*.d.ts', + 'packages/core/src/teleportation/trajectory_teleporter.min.js', ], }, eslint.configs.recommended, diff --git a/packages/core/package.json b/packages/core/package.json index de105d4389..4fb7b0d227 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -12,6 +12,7 @@ "scripts": { "bundle:browser-mcp": "node scripts/bundle-browser-mcp.mjs", "build": "node ../../scripts/build_package.js", + "build:teleporter": "./scripts/build-teleporter.sh", "lint": "eslint . --ext .ts,.tsx", "format": "prettier --write .", "test": "vitest run", diff --git a/packages/core/scripts/build-teleporter.sh b/packages/core/scripts/build-teleporter.sh new file mode 100755 index 0000000000..1683b3ba36 --- /dev/null +++ b/packages/core/scripts/build-teleporter.sh @@ -0,0 +1,34 @@ +#!/bin/bash +set -e + +# Define paths +CLI_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)" +EXA_ROOT="$(cd "$CLI_ROOT/../jetski/Exafunction" && pwd)" +TELEPORTER_TS="$CLI_ROOT/packages/core/src/teleportation/trajectory_teleporter.ts" +TELEPORTER_MIN_JS="$CLI_ROOT/packages/core/src/teleportation/trajectory_teleporter.min.js" + +if [ ! -d "$EXA_ROOT" ]; then + echo "Error: Exafunction directory not found at $EXA_ROOT" + exit 1 +fi + +echo "Building Protobuf JS definitions in Exafunction..." +cd "$EXA_ROOT" +pnpm --dir exa/proto_ts build + +echo "Bundling and minifying trajectory_teleporter.ts..." +# Because esbuild resolves relative imports from the source file's directory, +# and trajectory_teleporter.ts playfully imports './exa/...', we copy it to EXA_ROOT +# temporarily for the build step to succeed. +cp "$TELEPORTER_TS" "$EXA_ROOT/trajectory_teleporter_tmp.ts" + +cd "$EXA_ROOT" +pnpm dlx esbuild "./trajectory_teleporter_tmp.ts" \ + --bundle \ + --format=esm \ + --platform=node \ + --outfile="$TELEPORTER_MIN_JS" + +rm "$EXA_ROOT/trajectory_teleporter_tmp.ts" + +echo "Done! Wrote bundle to $TELEPORTER_MIN_JS" diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index 47412dd73c..d2318fc5aa 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -221,6 +221,8 @@ export * from './telemetry/constants.js'; export { sessionId, createSessionId } from './utils/session.js'; export * from './utils/compatibility.js'; export * from './utils/browser.js'; +export * from './teleportation/index.js'; + export { Storage } from './config/storage.js'; // Export hooks system diff --git a/packages/core/src/teleportation/agyProvider.ts b/packages/core/src/teleportation/agyProvider.ts new file mode 100644 index 0000000000..bc4ed4245f --- /dev/null +++ b/packages/core/src/teleportation/agyProvider.ts @@ -0,0 +1,41 @@ +/** + * @license + * Copyright 2026 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +import { listAgySessions, loadAgySession } from './discovery.js'; +import { trajectoryToJson } from './teleporter.js'; +import { convertAgyToCliRecord } from './converter.js'; +import type { + TrajectoryProvider, + ConversationRecord, +} from '../config/config.js'; + +/** + * Trajectory provider for Antigravity (Jetski) sessions. + */ +const agyProvider: TrajectoryProvider = { + prefix: 'agy:', + displayName: 'Antigravity', + + async listSessions(workspaceUri?: string) { + const sessions = await listAgySessions(workspaceUri); + return sessions.map((s) => ({ + id: s.id, + mtime: s.mtime, + displayName: s.displayName, + messageCount: s.messageCount, + })); + }, + + async loadSession(id: string): Promise { + const data = await loadAgySession(id); + if (!data) return null; + const json = trajectoryToJson(data); + return convertAgyToCliRecord(json); + }, +}; + +// eslint-disable-next-line import/no-default-export +export default agyProvider; diff --git a/packages/core/src/teleportation/converter.ts b/packages/core/src/teleportation/converter.ts new file mode 100644 index 0000000000..73cd1e895a --- /dev/null +++ b/packages/core/src/teleportation/converter.ts @@ -0,0 +1,278 @@ +/** + * @license + * Copyright 2025 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +/* eslint-disable @typescript-eslint/no-unsafe-type-assertion */ + +import type { + ConversationRecord, + ToolCallRecord, + MessageRecord, +} from '../services/chatRecordingService.js'; +import { CoreToolCallStatus } from '../scheduler/types.js'; +import { + /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return */ + + EDIT_TOOL_NAME, + GLOB_TOOL_NAME, + GREP_TOOL_NAME, + LS_TOOL_NAME, + READ_FILE_TOOL_NAME, + SHELL_TOOL_NAME, + WEB_FETCH_TOOL_NAME, + WEB_SEARCH_TOOL_NAME, + WRITE_FILE_TOOL_NAME, + ASK_USER_TOOL_NAME, +} from '../tools/definitions/coreTools.js'; + +/** + * Converts an Antigravity Trajectory JSON to a Gemini CLI ConversationRecord. + */ +export function convertAgyToCliRecord(agyJson: unknown): ConversationRecord { + if (typeof agyJson !== 'object' || agyJson === null) { + throw new Error('Invalid AGY JSON'); + } + const json = agyJson as Record; + const messages: MessageRecord[] = []; + const sessionId = (json['trajectoryId'] as string) || 'agy-session'; + const startTime = new Date().toISOString(); // Default to now if not found + + let currentGeminiMessage: (MessageRecord & { type: 'gemini' }) | null = null; + + const steps = (json['steps'] as any[]) || []; + + for (const step of steps) { + const s = step as Record; + const metadata = s['metadata'] as Record | undefined; + const timestamp = + (metadata?.['timestamp'] as string) || new Date().toISOString(); + const stepId = + (metadata?.['stepId'] as string) || + Math.random().toString(36).substring(7); + + switch (s['type']) { + case 14: // CORTEX_STEP_TYPE_USER_INPUT + case 'CORTEX_STEP_TYPE_USER_INPUT': { + // Close current Gemini message if open + currentGeminiMessage = null; + const userInput = s['userInput'] as Record | undefined; + messages.push({ + id: stepId, + timestamp, + type: 'user', + content: [{ text: (userInput?.['userResponse'] as string) || '' }], + }); + break; + } + + case 15: // CORTEX_STEP_TYPE_PLANNER_RESPONSE + case 'CORTEX_STEP_TYPE_PLANNER_RESPONSE': { + const plannerResponse = s['plannerResponse'] as + | Record + | undefined; + const response = plannerResponse?.['response'] || ''; + const thinking = plannerResponse?.['thinking'] || ''; + currentGeminiMessage = { + id: stepId, + timestamp, + type: 'gemini', + content: [{ text: response as string }], + thoughts: thinking + ? [ + { + subject: 'Thinking', + description: thinking as string, + timestamp, + }, + ] + : [], + toolCalls: [], + }; + messages.push(currentGeminiMessage); + break; + } + + case 7: // CORTEX_STEP_TYPE_GREP_SEARCH + case 'CORTEX_STEP_TYPE_GREP_SEARCH': + case 8: // CORTEX_STEP_TYPE_VIEW_FILE + case 'CORTEX_STEP_TYPE_VIEW_FILE': + case 9: // CORTEX_STEP_TYPE_LIST_DIRECTORY + case 'CORTEX_STEP_TYPE_LIST_DIRECTORY': + case 21: // CORTEX_STEP_TYPE_RUN_COMMAND + case 'CORTEX_STEP_TYPE_RUN_COMMAND': + case 23: // CORTEX_STEP_TYPE_WRITE_TO_FILE + case 'CORTEX_STEP_TYPE_WRITE_TO_FILE': + case 25: // CORTEX_STEP_TYPE_FIND + case 'CORTEX_STEP_TYPE_FIND': + case 31: // CORTEX_STEP_TYPE_READ_URL_CONTENT + case 'CORTEX_STEP_TYPE_READ_URL_CONTENT': + case 33: // CORTEX_STEP_TYPE_SEARCH_WEB + case 'CORTEX_STEP_TYPE_SEARCH_WEB': + case 38: // CORTEX_STEP_TYPE_MCP_TOOL + case 'CORTEX_STEP_TYPE_MCP_TOOL': + case 85: // CORTEX_STEP_TYPE_BROWSER_SUBAGENT + case 'CORTEX_STEP_TYPE_BROWSER_SUBAGENT': + case 86: // CORTEX_STEP_TYPE_FILE_CHANGE + case 'CORTEX_STEP_TYPE_FILE_CHANGE': + case 140: // CORTEX_STEP_TYPE_GENERIC + case 'CORTEX_STEP_TYPE_GENERIC': { + if (!currentGeminiMessage) { + // If no planner response preceded this, create a dummy one + const adjunctMessage: MessageRecord = { + id: `adjunct-${stepId}`, + timestamp, + type: 'gemini', + content: [], + toolCalls: [], + thoughts: [], + }; + messages.push(adjunctMessage); + currentGeminiMessage = adjunctMessage as MessageRecord & { + type: 'gemini'; + }; + } + + if (currentGeminiMessage) { + currentGeminiMessage.toolCalls?.push(mapAgyStepToToolCall(s)); + } + break; + } + + default: + // Skip unknown steps + break; + } + } + + return { + sessionId, + projectHash: 'agy-imported', + startTime, + lastUpdated: new Date().toISOString(), + messages, + }; +} + +function mapAgyStepToToolCall(step: Record): ToolCallRecord { + const timestamp = + (step['metadata']?.['timestamp'] as string) || new Date().toISOString(); + const id = + (step['metadata']?.['stepId'] as string) || + Math.random().toString(36).substring(7); + let name = 'unknown_tool'; + let args: any = {}; + let result: any = null; + + if (step['viewFile']) { + name = READ_FILE_TOOL_NAME; + args = { AbsolutePath: step['viewFile']['absolutePathUri'] }; + result = [{ text: step['viewFile']['content'] || '' }]; + } else if (step['listDirectory']) { + name = LS_TOOL_NAME; + args = { DirectoryPath: step['listDirectory']['directoryPathUri'] }; + } else if (step['grepSearch']) { + name = GREP_TOOL_NAME; + args = { + Query: step['grepSearch']['query'], + SearchPath: step['grepSearch']['searchPathUri'], + }; + result = [{ text: step['grepSearch']['rawOutput'] || '' }]; + } else if (step['runCommand']) { + name = SHELL_TOOL_NAME; + args = { CommandLine: step['runCommand']['commandLine'] }; + result = [{ text: step['runCommand']['combinedOutput']?.['full'] || '' }]; + } else if (step['fileChange']) { + name = EDIT_TOOL_NAME; // Or multi_replace_file_content + args = { TargetFile: step['fileChange']['absolutePathUri'] }; + } else if (step['writeToFile']) { + name = WRITE_FILE_TOOL_NAME; + args = { TargetFile: step['writeToFile']['targetFileUri'] }; + } else if (step['find']) { + name = GLOB_TOOL_NAME; + args = { + Pattern: step['find']['pattern'], + SearchDirectory: step['find']['searchDirectory'], + }; + result = [{ text: step['find']['truncatedOutput'] || '' }]; + } else if (step['readUrlContent']) { + name = WEB_FETCH_TOOL_NAME; + args = { Url: step['readUrlContent']['url'] }; + // We intentionally don't try fully mapping the complex KnowledgeBaseItem struct into a string here + result = [{ text: 'successfully read url content' }]; + } else if (step['searchWeb']) { + name = WEB_SEARCH_TOOL_NAME; // Usually mapped from 'searchWeb' + args = { query: step['searchWeb']['query'] }; + if (step['searchWeb']['domain']) { + args['domain'] = step['searchWeb']['domain']; + } + result = [{ text: 'successfully searched web' }]; + } else if (step['mcpTool']) { + const mcpStep = step['mcpTool']; + name = mcpStep['toolCall']?.['name'] || 'unknown_mcp_tool'; + try { + if (mcpStep['toolCall']?.['arguments']) { + args = JSON.parse(mcpStep['toolCall']['arguments']); + } + } catch { + args = {}; + } + result = [{ text: mcpStep['resultString'] || '' }]; + } else if (step['browserSubagent']) { + name = 'browser_subagent'; + args = { Task: step['browserSubagent']['task'] }; + } else if (step['generic']) { + const generic = step['generic'] as Record; + const rawName = generic['toolName'] as string; + + // Map generic tools to official CLI constants where applicable + if (rawName === 'ask_user') { + name = ASK_USER_TOOL_NAME; + } else { + name = rawName; + } + + try { + args = JSON.parse(generic['argsJson'] as string); + } catch { + args = {}; + } + result = [{ text: (generic['responseJson'] as string) || '' }]; + } + + const safeArgs = args as Record; + const status = + step['status'] === 3 || step['status'] === 'CORTEX_STEP_STATUS_DONE' + ? CoreToolCallStatus.Success + : CoreToolCallStatus.Error; + + // Synthesize a UI string from the args so it isn't blank in the terminal + const argValues = Object.values(safeArgs) + .filter((v) => typeof v === 'string' || typeof v === 'number') + .join(', '); + const description = argValues || ''; + + // Synthesize a UI string for the result output + let resultDisplay: string | undefined = undefined; + if (Array.isArray(result) && result.length > 0) { + const textParts = result + .map((part) => part?.text) + .filter((text) => typeof text === 'string' && text.length > 0); + + if (textParts.length > 0) { + resultDisplay = textParts.join('\n'); + } + } + + return { + id, + name, + args: safeArgs, + description, + result, + resultDisplay, + status, + timestamp, + }; +} diff --git a/packages/core/src/teleportation/discovery.ts b/packages/core/src/teleportation/discovery.ts new file mode 100644 index 0000000000..7488a4dd17 --- /dev/null +++ b/packages/core/src/teleportation/discovery.ts @@ -0,0 +1,199 @@ +/** + * @license + * Copyright 2025 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +/* eslint-disable @typescript-eslint/no-unsafe-type-assertion */ +import fs from 'node:fs/promises'; +import path from 'node:path'; +import os from 'node:os'; +import { trajectoryToJson } from './teleporter.js'; +import { convertAgyToCliRecord } from './converter.js'; +import { partListUnionToString } from '../core/geminiRequest.js'; +import type { MessageRecord } from '../services/chatRecordingService.js'; + +export interface AgySessionInfo { + id: string; + path: string; + mtime: string; + displayName?: string; + messageCount?: number; + workspaceUri?: string; +} + +const AGY_CONVERSATIONS_DIR = path.join( + os.homedir(), + '.gemini', + 'jetski', + 'conversations', +); + +const AGY_KEY_PATH = path.join(os.homedir(), '.gemini', 'jetski', 'key.txt'); + +/** + * Loads the Antigravity encryption key. + * Priority: JETSKI_TELEPORT_KEY env var > ~/.gemini/jetski/key.txt + */ +export async function loadAgyKey(): Promise { + const envKey = process.env['JETSKI_TELEPORT_KEY']; + if (envKey) { + return Buffer.from(envKey); + } + + try { + const keyContent = await fs.readFile(AGY_KEY_PATH, 'utf-8'); + return Buffer.from(keyContent.trim()); + } catch (_e) { + return undefined; + } +} + +/** + * Lists all Antigravity sessions found on disk. + * @param filterWorkspaceUri Optional filter to only return sessions matching this workspace URI (e.g. "file:///..."). + */ +export async function listAgySessions( + filterWorkspaceUri?: string, +): Promise { + try { + const files = await fs.readdir(AGY_CONVERSATIONS_DIR); + const sessions: AgySessionInfo[] = []; + for (const file of files) { + if (file.endsWith('.pb')) { + const filePath = path.join(AGY_CONVERSATIONS_DIR, file); + const stats = await fs.stat(filePath); + const id = path.basename(file, '.pb'); + + let details: ReturnType = {}; + try { + const data = await fs.readFile(filePath); + const json = trajectoryToJson(data); + details = extractAgyDetails(json); + } catch (_error) { + // Ignore errors during parsing + } + + if ( + filterWorkspaceUri && + details.workspaceUri && + details.workspaceUri !== filterWorkspaceUri + ) { + continue; // Skip sessions from other workspaces if we have a filter + } + + sessions.push({ + id, + path: filePath, + mtime: stats.mtime.toISOString(), + ...details, + }); + } + } + + return sessions; + } catch (_error) { + // If directory doesn't exist, just return empty list + return []; + } +} + +function extractAgyDetails(json: unknown): { + displayName?: string; + messageCount?: number; + workspaceUri?: string; +} { + try { + const record = convertAgyToCliRecord(json); + const messages = record.messages || []; + + // Find first user message for display name + const firstUserMsg = messages.find((m: MessageRecord) => m.type === 'user'); + const displayName = firstUserMsg + ? partListUnionToString(firstUserMsg.content).slice(0, 100) + : 'Antigravity Session'; + + // Attempt to extract authoritative workspace object from top-level metadata first + let workspaceUri: string | undefined; + const agyJson = json as Record; + + const metadata = agyJson['metadata'] as Record | undefined; + if (metadata) { + const workspaces = metadata['workspaces'] as + | Array> + | undefined; + const firstWorkspace = workspaces?.[0]; + if (firstWorkspace && firstWorkspace['workspaceFolderAbsoluteUri']) { + workspaceUri = firstWorkspace['workspaceFolderAbsoluteUri'] as string; + } + } + + // Fallback: Attempt to extract workspace object from raw JSON steps (e.g. older offline trajectories) + if (!workspaceUri) { + const steps = (agyJson['steps'] as Array>) || []; + for (const step of steps) { + const userInput = step['userInput'] as + | Record + | undefined; + if (userInput) { + const activeState = userInput['activeUserState'] as + | Record + | undefined; + const activeDoc = activeState?.['activeDocument'] as + | Record + | undefined; + if (activeDoc && activeDoc['workspaceUri']) { + workspaceUri = activeDoc['workspaceUri'] as string; + break; + } + } + } + } + + return { + displayName, + messageCount: messages.length, + workspaceUri, + }; + } catch (_error) { + return {}; + } +} + +/** + * Loads the raw binary data of an Antigravity session. + */ +export async function loadAgySession(id: string): Promise { + const filePath = path.join(AGY_CONVERSATIONS_DIR, `${id}.pb`); + try { + return await fs.readFile(filePath); + } catch (_error) { + return null; + } +} + +/** + * Returns the most recent session if it was updated within the last 10 minutes. + */ +export async function getRecentAgySession( + workspaceUri?: string, +): Promise { + const sessions = await listAgySessions(workspaceUri); + if (sessions.length === 0) return null; + + // Sort by mtime descending + const sorted = sessions.sort( + (a, b) => new Date(b.mtime).getTime() - new Date(a.mtime).getTime(), + ); + + const mostRecent = sorted[0]; + const mtime = new Date(mostRecent.mtime).getTime(); + const now = Date.now(); + + // 10 minutes threshold + if (now - mtime < 10 * 60 * 1000) { + return mostRecent; + } + + return null; +} diff --git a/packages/core/src/teleportation/index.ts b/packages/core/src/teleportation/index.ts new file mode 100644 index 0000000000..caebf0f5ef --- /dev/null +++ b/packages/core/src/teleportation/index.ts @@ -0,0 +1,15 @@ +/** + * @license + * Copyright 2025 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +export interface AgyTrajectory { + trajectoryId: string; + cascadeId: string; + trajectoryType: number; + steps: unknown[]; +} + +export * from './teleporter.js'; +export { convertAgyToCliRecord } from './converter.js'; diff --git a/packages/core/src/teleportation/teleporter.ts b/packages/core/src/teleportation/teleporter.ts new file mode 100644 index 0000000000..7e51394c47 --- /dev/null +++ b/packages/core/src/teleportation/teleporter.ts @@ -0,0 +1,21 @@ +/** + * @license + * Copyright 2025 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +import * as teleporter from './trajectory_teleporter.min.js'; + +/** + * Decrypts and parses an Antigravity trajectory file (.pb) into JSON. + */ +export function trajectoryToJson(data: Buffer): unknown { + return teleporter.trajectoryToJson(data); +} + +/** + * Converts a JSON trajectory back to encrypted binary format. + */ +export function jsonToTrajectory(json: unknown): Buffer { + return teleporter.jsonToTrajectory(json); +} diff --git a/packages/core/src/teleportation/trajectory_teleporter.min.d.ts b/packages/core/src/teleportation/trajectory_teleporter.min.d.ts new file mode 100644 index 0000000000..4f2a250097 --- /dev/null +++ b/packages/core/src/teleportation/trajectory_teleporter.min.d.ts @@ -0,0 +1,10 @@ +/** + * @license + * Copyright 2026 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +export function trajectoryToJson(data: Buffer): unknown; +export function jsonToTrajectory(json: unknown): Buffer; +export function decrypt(data: Buffer): unknown; +export function encrypt(data: Buffer): Buffer; diff --git a/packages/core/src/teleportation/trajectory_teleporter.min.js b/packages/core/src/teleportation/trajectory_teleporter.min.js new file mode 100644 index 0000000000..f13ad8f563 --- /dev/null +++ b/packages/core/src/teleportation/trajectory_teleporter.min.js @@ -0,0 +1,67142 @@ +// trajectory_teleporter_tmp.ts +import * as crypto from 'node:crypto'; + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/assert.js +function assert(condition, msg) { + if (!condition) { + throw new Error(msg); + } +} +var FLOAT32_MAX = 34028234663852886e22; +var FLOAT32_MIN = -34028234663852886e22; +var UINT32_MAX = 4294967295; +var INT32_MAX = 2147483647; +var INT32_MIN = -2147483648; +function assertInt32(arg) { + if (typeof arg !== 'number') throw new Error('invalid int 32: ' + typeof arg); + if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN) + throw new Error('invalid int 32: ' + arg); +} +function assertUInt32(arg) { + if (typeof arg !== 'number') + throw new Error('invalid uint 32: ' + typeof arg); + if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0) + throw new Error('invalid uint 32: ' + arg); +} +function assertFloat32(arg) { + if (typeof arg !== 'number') + throw new Error('invalid float 32: ' + typeof arg); + if (!Number.isFinite(arg)) return; + if (arg > FLOAT32_MAX || arg < FLOAT32_MIN) + throw new Error('invalid float 32: ' + arg); +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/enum.js +var enumTypeSymbol = /* @__PURE__ */ Symbol('@bufbuild/protobuf/enum-type'); +function getEnumType(enumObject) { + const t = enumObject[enumTypeSymbol]; + assert(t, 'missing enum type on enum object'); + return t; +} +function setEnumType(enumObject, typeName, values, opt) { + enumObject[enumTypeSymbol] = makeEnumType( + typeName, + values.map((v) => ({ + no: v.no, + name: v.name, + localName: enumObject[v.no], + })), + opt, + ); +} +function makeEnumType(typeName, values, _opt) { + const names = /* @__PURE__ */ Object.create(null); + const numbers = /* @__PURE__ */ Object.create(null); + const normalValues = []; + for (const value of values) { + const n = normalizeEnumValue(value); + normalValues.push(n); + names[value.name] = n; + numbers[value.no] = n; + } + return { + typeName, + values: normalValues, + // We do not surface options at this time + // options: opt?.options ?? Object.create(null), + findName(name) { + return names[name]; + }, + findNumber(no) { + return numbers[no]; + }, + }; +} +function makeEnum(typeName, values, opt) { + const enumObject = {}; + for (const value of values) { + const n = normalizeEnumValue(value); + enumObject[n.localName] = n.no; + enumObject[n.no] = n.localName; + } + setEnumType(enumObject, typeName, values, opt); + return enumObject; +} +function normalizeEnumValue(value) { + if ('localName' in value) { + return value; + } + return Object.assign(Object.assign({}, value), { localName: value.name }); +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/message.js +var Message = class { + /** + * Compare with a message of the same type. + * Note that this function disregards extensions and unknown fields. + */ + equals(other) { + return this.getType().runtime.util.equals(this.getType(), this, other); + } + /** + * Create a deep copy. + */ + clone() { + return this.getType().runtime.util.clone(this); + } + /** + * Parse from binary data, merging fields. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ + fromBinary(bytes, options) { + const type = this.getType(), + format = type.runtime.bin, + opt = format.makeReadOptions(options); + format.readMessage(this, opt.readerFactory(bytes), bytes.byteLength, opt); + return this; + } + /** + * Parse a message from a JSON value. + */ + fromJson(jsonValue, options) { + const type = this.getType(), + format = type.runtime.json, + opt = format.makeReadOptions(options); + format.readMessage(type, jsonValue, opt, this); + return this; + } + /** + * Parse a message from a JSON string. + */ + fromJsonString(jsonString, options) { + let json; + try { + json = JSON.parse(jsonString); + } catch (e) { + throw new Error( + `cannot decode ${this.getType().typeName} from JSON: ${e instanceof Error ? e.message : String(e)}`, + ); + } + return this.fromJson(json, options); + } + /** + * Serialize the message to binary data. + */ + toBinary(options) { + const type = this.getType(), + bin = type.runtime.bin, + opt = bin.makeWriteOptions(options), + writer = opt.writerFactory(); + bin.writeMessage(this, writer, opt); + return writer.finish(); + } + /** + * Serialize the message to a JSON value, a JavaScript value that can be + * passed to JSON.stringify(). + */ + toJson(options) { + const type = this.getType(), + json = type.runtime.json, + opt = json.makeWriteOptions(options); + return json.writeMessage(this, opt); + } + /** + * Serialize the message to a JSON string. + */ + toJsonString(options) { + var _a; + const value = this.toJson(options); + return JSON.stringify( + value, + null, + (_a = + options === null || options === void 0 + ? void 0 + : options.prettySpaces) !== null && _a !== void 0 + ? _a + : 0, + ); + } + /** + * Override for serialization behavior. This will be invoked when calling + * JSON.stringify on this message (i.e. JSON.stringify(msg)). + * + * Note that this will not serialize google.protobuf.Any with a packed + * message because the protobuf JSON format specifies that it needs to be + * unpacked, and this is only possible with a type registry to look up the + * message type. As a result, attempting to serialize a message with this + * type will throw an Error. + * + * This method is protected because you should not need to invoke it + * directly -- instead use JSON.stringify or toJsonString for + * stringified JSON. Alternatively, if actual JSON is desired, you should + * use toJson. + */ + toJSON() { + return this.toJson({ + emitDefaultValues: true, + }); + } + /** + * Retrieve the MessageType of this message - a singleton that represents + * the protobuf message declaration and provides metadata for reflection- + * based operations. + */ + getType() { + return Object.getPrototypeOf(this).constructor; + } +}; + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/message-type.js +function makeMessageType(runtime, typeName, fields, opt) { + var _a; + const localName = + (_a = opt === null || opt === void 0 ? void 0 : opt.localName) !== null && + _a !== void 0 + ? _a + : typeName.substring(typeName.lastIndexOf('.') + 1); + const type = { + [localName]: function (data) { + runtime.util.initFields(this); + runtime.util.initPartial(data, this); + }, + }[localName]; + Object.setPrototypeOf(type.prototype, new Message()); + Object.assign(type, { + runtime, + typeName, + fields: runtime.util.newFieldList(fields), + fromBinary(bytes, options) { + return new type().fromBinary(bytes, options); + }, + fromJson(jsonValue, options) { + return new type().fromJson(jsonValue, options); + }, + fromJsonString(jsonString, options) { + return new type().fromJsonString(jsonString, options); + }, + equals(a, b) { + return runtime.util.equals(type, a, b); + }, + }); + return type; +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/google/varint.js +function varint64read() { + let lowBits = 0; + let highBits = 0; + for (let shift = 0; shift < 28; shift += 7) { + let b = this.buf[this.pos++]; + lowBits |= (b & 127) << shift; + if ((b & 128) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + } + let middleByte = this.buf[this.pos++]; + lowBits |= (middleByte & 15) << 28; + highBits = (middleByte & 112) >> 4; + if ((middleByte & 128) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + for (let shift = 3; shift <= 31; shift += 7) { + let b = this.buf[this.pos++]; + highBits |= (b & 127) << shift; + if ((b & 128) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + } + throw new Error('invalid varint'); +} +function varint64write(lo, hi, bytes) { + for (let i = 0; i < 28; i = i + 7) { + const shift = lo >>> i; + const hasNext = !(shift >>> 7 == 0 && hi == 0); + const byte = (hasNext ? shift | 128 : shift) & 255; + bytes.push(byte); + if (!hasNext) { + return; + } + } + const splitBits = ((lo >>> 28) & 15) | ((hi & 7) << 4); + const hasMoreBits = !(hi >> 3 == 0); + bytes.push((hasMoreBits ? splitBits | 128 : splitBits) & 255); + if (!hasMoreBits) { + return; + } + for (let i = 3; i < 31; i = i + 7) { + const shift = hi >>> i; + const hasNext = !(shift >>> 7 == 0); + const byte = (hasNext ? shift | 128 : shift) & 255; + bytes.push(byte); + if (!hasNext) { + return; + } + } + bytes.push((hi >>> 31) & 1); +} +var TWO_PWR_32_DBL = 4294967296; +function int64FromString(dec) { + const minus = dec[0] === '-'; + if (minus) { + dec = dec.slice(1); + } + const base = 1e6; + let lowBits = 0; + let highBits = 0; + function add1e6digit(begin, end) { + const digit1e6 = Number(dec.slice(begin, end)); + highBits *= base; + lowBits = lowBits * base + digit1e6; + if (lowBits >= TWO_PWR_32_DBL) { + highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0); + lowBits = lowBits % TWO_PWR_32_DBL; + } + } + add1e6digit(-24, -18); + add1e6digit(-18, -12); + add1e6digit(-12, -6); + add1e6digit(-6); + return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits); +} +function int64ToString(lo, hi) { + let bits = newBits(lo, hi); + const negative = bits.hi & 2147483648; + if (negative) { + bits = negate(bits.lo, bits.hi); + } + const result = uInt64ToString(bits.lo, bits.hi); + return negative ? '-' + result : result; +} +function uInt64ToString(lo, hi) { + ({ lo, hi } = toUnsigned(lo, hi)); + if (hi <= 2097151) { + return String(TWO_PWR_32_DBL * hi + lo); + } + const low = lo & 16777215; + const mid = ((lo >>> 24) | (hi << 8)) & 16777215; + const high = (hi >> 16) & 65535; + let digitA = low + mid * 6777216 + high * 6710656; + let digitB = mid + high * 8147497; + let digitC = high * 2; + const base = 1e7; + if (digitA >= base) { + digitB += Math.floor(digitA / base); + digitA %= base; + } + if (digitB >= base) { + digitC += Math.floor(digitB / base); + digitB %= base; + } + return ( + digitC.toString() + + decimalFrom1e7WithLeadingZeros(digitB) + + decimalFrom1e7WithLeadingZeros(digitA) + ); +} +function toUnsigned(lo, hi) { + return { lo: lo >>> 0, hi: hi >>> 0 }; +} +function newBits(lo, hi) { + return { lo: lo | 0, hi: hi | 0 }; +} +function negate(lowBits, highBits) { + highBits = ~highBits; + if (lowBits) { + lowBits = ~lowBits + 1; + } else { + highBits += 1; + } + return newBits(lowBits, highBits); +} +var decimalFrom1e7WithLeadingZeros = (digit1e7) => { + const partial = String(digit1e7); + return '0000000'.slice(partial.length) + partial; +}; +function varint32write(value, bytes) { + if (value >= 0) { + while (value > 127) { + bytes.push((value & 127) | 128); + value = value >>> 7; + } + bytes.push(value); + } else { + for (let i = 0; i < 9; i++) { + bytes.push((value & 127) | 128); + value = value >> 7; + } + bytes.push(1); + } +} +function varint32read() { + let b = this.buf[this.pos++]; + let result = b & 127; + if ((b & 128) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 127) << 7; + if ((b & 128) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 127) << 14; + if ((b & 128) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 127) << 21; + if ((b & 128) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 15) << 28; + for (let readBytes = 5; (b & 128) !== 0 && readBytes < 10; readBytes++) + b = this.buf[this.pos++]; + if ((b & 128) != 0) throw new Error('invalid varint'); + this.assertBounds(); + return result >>> 0; +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js +function makeInt64Support() { + const dv = new DataView(new ArrayBuffer(8)); + const ok = + typeof BigInt === 'function' && + typeof dv.getBigInt64 === 'function' && + typeof dv.getBigUint64 === 'function' && + typeof dv.setBigInt64 === 'function' && + typeof dv.setBigUint64 === 'function' && + (typeof process != 'object' || + typeof process.env != 'object' || + process.env.BUF_BIGINT_DISABLE !== '1'); + if (ok) { + const MIN = BigInt('-9223372036854775808'), + MAX = BigInt('9223372036854775807'), + UMIN = BigInt('0'), + UMAX = BigInt('18446744073709551615'); + return { + zero: BigInt(0), + supported: true, + parse(value) { + const bi = typeof value == 'bigint' ? value : BigInt(value); + if (bi > MAX || bi < MIN) { + throw new Error(`int64 invalid: ${value}`); + } + return bi; + }, + uParse(value) { + const bi = typeof value == 'bigint' ? value : BigInt(value); + if (bi > UMAX || bi < UMIN) { + throw new Error(`uint64 invalid: ${value}`); + } + return bi; + }, + enc(value) { + dv.setBigInt64(0, this.parse(value), true); + return { + lo: dv.getInt32(0, true), + hi: dv.getInt32(4, true), + }; + }, + uEnc(value) { + dv.setBigInt64(0, this.uParse(value), true); + return { + lo: dv.getInt32(0, true), + hi: dv.getInt32(4, true), + }; + }, + dec(lo, hi) { + dv.setInt32(0, lo, true); + dv.setInt32(4, hi, true); + return dv.getBigInt64(0, true); + }, + uDec(lo, hi) { + dv.setInt32(0, lo, true); + dv.setInt32(4, hi, true); + return dv.getBigUint64(0, true); + }, + }; + } + const assertInt64String = (value) => + assert(/^-?[0-9]+$/.test(value), `int64 invalid: ${value}`); + const assertUInt64String = (value) => + assert(/^[0-9]+$/.test(value), `uint64 invalid: ${value}`); + return { + zero: '0', + supported: false, + parse(value) { + if (typeof value != 'string') { + value = value.toString(); + } + assertInt64String(value); + return value; + }, + uParse(value) { + if (typeof value != 'string') { + value = value.toString(); + } + assertUInt64String(value); + return value; + }, + enc(value) { + if (typeof value != 'string') { + value = value.toString(); + } + assertInt64String(value); + return int64FromString(value); + }, + uEnc(value) { + if (typeof value != 'string') { + value = value.toString(); + } + assertUInt64String(value); + return int64FromString(value); + }, + dec(lo, hi) { + return int64ToString(lo, hi); + }, + uDec(lo, hi) { + return uInt64ToString(lo, hi); + }, + }; +} +var protoInt64 = makeInt64Support(); + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/scalar.js +var ScalarType; +(function (ScalarType2) { + ScalarType2[(ScalarType2['DOUBLE'] = 1)] = 'DOUBLE'; + ScalarType2[(ScalarType2['FLOAT'] = 2)] = 'FLOAT'; + ScalarType2[(ScalarType2['INT64'] = 3)] = 'INT64'; + ScalarType2[(ScalarType2['UINT64'] = 4)] = 'UINT64'; + ScalarType2[(ScalarType2['INT32'] = 5)] = 'INT32'; + ScalarType2[(ScalarType2['FIXED64'] = 6)] = 'FIXED64'; + ScalarType2[(ScalarType2['FIXED32'] = 7)] = 'FIXED32'; + ScalarType2[(ScalarType2['BOOL'] = 8)] = 'BOOL'; + ScalarType2[(ScalarType2['STRING'] = 9)] = 'STRING'; + ScalarType2[(ScalarType2['BYTES'] = 12)] = 'BYTES'; + ScalarType2[(ScalarType2['UINT32'] = 13)] = 'UINT32'; + ScalarType2[(ScalarType2['SFIXED32'] = 15)] = 'SFIXED32'; + ScalarType2[(ScalarType2['SFIXED64'] = 16)] = 'SFIXED64'; + ScalarType2[(ScalarType2['SINT32'] = 17)] = 'SINT32'; + ScalarType2[(ScalarType2['SINT64'] = 18)] = 'SINT64'; +})(ScalarType || (ScalarType = {})); +var LongType; +(function (LongType2) { + LongType2[(LongType2['BIGINT'] = 0)] = 'BIGINT'; + LongType2[(LongType2['STRING'] = 1)] = 'STRING'; +})(LongType || (LongType = {})); + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/scalars.js +function scalarEquals(type, a, b) { + if (a === b) { + return true; + } + if (type == ScalarType.BYTES) { + if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) { + return false; + } + if (a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; i++) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + } + switch (type) { + case ScalarType.UINT64: + case ScalarType.FIXED64: + case ScalarType.INT64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + return a == b; + } + return false; +} +function scalarZeroValue(type, longType) { + switch (type) { + case ScalarType.BOOL: + return false; + case ScalarType.UINT64: + case ScalarType.FIXED64: + case ScalarType.INT64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + return longType == 0 ? protoInt64.zero : '0'; + case ScalarType.DOUBLE: + case ScalarType.FLOAT: + return 0; + case ScalarType.BYTES: + return new Uint8Array(0); + case ScalarType.STRING: + return ''; + default: + return 0; + } +} +function isScalarZeroValue(type, value) { + switch (type) { + case ScalarType.BOOL: + return value === false; + case ScalarType.STRING: + return value === ''; + case ScalarType.BYTES: + return value instanceof Uint8Array && !value.byteLength; + default: + return value == 0; + } +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/binary-encoding.js +var WireType; +(function (WireType2) { + WireType2[(WireType2['Varint'] = 0)] = 'Varint'; + WireType2[(WireType2['Bit64'] = 1)] = 'Bit64'; + WireType2[(WireType2['LengthDelimited'] = 2)] = 'LengthDelimited'; + WireType2[(WireType2['StartGroup'] = 3)] = 'StartGroup'; + WireType2[(WireType2['EndGroup'] = 4)] = 'EndGroup'; + WireType2[(WireType2['Bit32'] = 5)] = 'Bit32'; +})(WireType || (WireType = {})); +var BinaryWriter = class { + constructor(textEncoder) { + this.stack = []; + this.textEncoder = + textEncoder !== null && textEncoder !== void 0 + ? textEncoder + : new TextEncoder(); + this.chunks = []; + this.buf = []; + } + /** + * Return all bytes written and reset this writer. + */ + finish() { + this.chunks.push(new Uint8Array(this.buf)); + let len = 0; + for (let i = 0; i < this.chunks.length; i++) len += this.chunks[i].length; + let bytes = new Uint8Array(len); + let offset = 0; + for (let i = 0; i < this.chunks.length; i++) { + bytes.set(this.chunks[i], offset); + offset += this.chunks[i].length; + } + this.chunks = []; + return bytes; + } + /** + * Start a new fork for length-delimited data like a message + * or a packed repeated field. + * + * Must be joined later with `join()`. + */ + fork() { + this.stack.push({ chunks: this.chunks, buf: this.buf }); + this.chunks = []; + this.buf = []; + return this; + } + /** + * Join the last fork. Write its length and bytes, then + * return to the previous state. + */ + join() { + let chunk = this.finish(); + let prev = this.stack.pop(); + if (!prev) throw new Error('invalid state, fork stack empty'); + this.chunks = prev.chunks; + this.buf = prev.buf; + this.uint32(chunk.byteLength); + return this.raw(chunk); + } + /** + * Writes a tag (field number and wire type). + * + * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`. + * + * Generated code should compute the tag ahead of time and call `uint32()`. + */ + tag(fieldNo, type) { + return this.uint32(((fieldNo << 3) | type) >>> 0); + } + /** + * Write a chunk of raw bytes. + */ + raw(chunk) { + if (this.buf.length) { + this.chunks.push(new Uint8Array(this.buf)); + this.buf = []; + } + this.chunks.push(chunk); + return this; + } + /** + * Write a `uint32` value, an unsigned 32 bit varint. + */ + uint32(value) { + assertUInt32(value); + while (value > 127) { + this.buf.push((value & 127) | 128); + value = value >>> 7; + } + this.buf.push(value); + return this; + } + /** + * Write a `int32` value, a signed 32 bit varint. + */ + int32(value) { + assertInt32(value); + varint32write(value, this.buf); + return this; + } + /** + * Write a `bool` value, a variant. + */ + bool(value) { + this.buf.push(value ? 1 : 0); + return this; + } + /** + * Write a `bytes` value, length-delimited arbitrary data. + */ + bytes(value) { + this.uint32(value.byteLength); + return this.raw(value); + } + /** + * Write a `string` value, length-delimited data converted to UTF-8 text. + */ + string(value) { + let chunk = this.textEncoder.encode(value); + this.uint32(chunk.byteLength); + return this.raw(chunk); + } + /** + * Write a `float` value, 32-bit floating point number. + */ + float(value) { + assertFloat32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setFloat32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `double` value, a 64-bit floating point number. + */ + double(value) { + let chunk = new Uint8Array(8); + new DataView(chunk.buffer).setFloat64(0, value, true); + return this.raw(chunk); + } + /** + * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer. + */ + fixed32(value) { + assertUInt32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setUint32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `sfixed32` value, a signed, fixed-length 32-bit integer. + */ + sfixed32(value) { + assertInt32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setInt32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint. + */ + sint32(value) { + assertInt32(value); + value = ((value << 1) ^ (value >> 31)) >>> 0; + varint32write(value, this.buf); + return this; + } + /** + * Write a `fixed64` value, a signed, fixed-length 64-bit integer. + */ + sfixed64(value) { + let chunk = new Uint8Array(8), + view = new DataView(chunk.buffer), + tc = protoInt64.enc(value); + view.setInt32(0, tc.lo, true); + view.setInt32(4, tc.hi, true); + return this.raw(chunk); + } + /** + * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer. + */ + fixed64(value) { + let chunk = new Uint8Array(8), + view = new DataView(chunk.buffer), + tc = protoInt64.uEnc(value); + view.setInt32(0, tc.lo, true); + view.setInt32(4, tc.hi, true); + return this.raw(chunk); + } + /** + * Write a `int64` value, a signed 64-bit varint. + */ + int64(value) { + let tc = protoInt64.enc(value); + varint64write(tc.lo, tc.hi, this.buf); + return this; + } + /** + * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint. + */ + sint64(value) { + let tc = protoInt64.enc(value), + sign = tc.hi >> 31, + lo = (tc.lo << 1) ^ sign, + hi = ((tc.hi << 1) | (tc.lo >>> 31)) ^ sign; + varint64write(lo, hi, this.buf); + return this; + } + /** + * Write a `uint64` value, an unsigned 64-bit varint. + */ + uint64(value) { + let tc = protoInt64.uEnc(value); + varint64write(tc.lo, tc.hi, this.buf); + return this; + } +}; +var BinaryReader = class { + constructor(buf, textDecoder) { + this.varint64 = varint64read; + this.uint32 = varint32read; + this.buf = buf; + this.len = buf.length; + this.pos = 0; + this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength); + this.textDecoder = + textDecoder !== null && textDecoder !== void 0 + ? textDecoder + : new TextDecoder(); + } + /** + * Reads a tag - field number and wire type. + */ + tag() { + let tag = this.uint32(), + fieldNo = tag >>> 3, + wireType = tag & 7; + if (fieldNo <= 0 || wireType < 0 || wireType > 5) + throw new Error( + 'illegal tag: field no ' + fieldNo + ' wire type ' + wireType, + ); + return [fieldNo, wireType]; + } + /** + * Skip one element on the wire and return the skipped data. + * Supports WireType.StartGroup since v2.0.0-alpha.23. + */ + skip(wireType) { + let start = this.pos; + switch (wireType) { + case WireType.Varint: + while (this.buf[this.pos++] & 128) {} + break; + // eslint-disable-next-line + // @ts-ignore TS7029: Fallthrough case in switch + case WireType.Bit64: + this.pos += 4; + // eslint-disable-next-line + // @ts-ignore TS7029: Fallthrough case in switch + case WireType.Bit32: + this.pos += 4; + break; + case WireType.LengthDelimited: + let len = this.uint32(); + this.pos += len; + break; + case WireType.StartGroup: + let t; + while ((t = this.tag()[1]) !== WireType.EndGroup) { + this.skip(t); + } + break; + default: + throw new Error('cant skip wire type ' + wireType); + } + this.assertBounds(); + return this.buf.subarray(start, this.pos); + } + /** + * Throws error if position in byte array is out of range. + */ + assertBounds() { + if (this.pos > this.len) throw new RangeError('premature EOF'); + } + /** + * Read a `int32` field, a signed 32 bit varint. + */ + int32() { + return this.uint32() | 0; + } + /** + * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint. + */ + sint32() { + let zze = this.uint32(); + return (zze >>> 1) ^ -(zze & 1); + } + /** + * Read a `int64` field, a signed 64-bit varint. + */ + int64() { + return protoInt64.dec(...this.varint64()); + } + /** + * Read a `uint64` field, an unsigned 64-bit varint. + */ + uint64() { + return protoInt64.uDec(...this.varint64()); + } + /** + * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint. + */ + sint64() { + let [lo, hi] = this.varint64(); + let s = -(lo & 1); + lo = ((lo >>> 1) | ((hi & 1) << 31)) ^ s; + hi = (hi >>> 1) ^ s; + return protoInt64.dec(lo, hi); + } + /** + * Read a `bool` field, a variant. + */ + bool() { + let [lo, hi] = this.varint64(); + return lo !== 0 || hi !== 0; + } + /** + * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer. + */ + fixed32() { + return this.view.getUint32((this.pos += 4) - 4, true); + } + /** + * Read a `sfixed32` field, a signed, fixed-length 32-bit integer. + */ + sfixed32() { + return this.view.getInt32((this.pos += 4) - 4, true); + } + /** + * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer. + */ + fixed64() { + return protoInt64.uDec(this.sfixed32(), this.sfixed32()); + } + /** + * Read a `fixed64` field, a signed, fixed-length 64-bit integer. + */ + sfixed64() { + return protoInt64.dec(this.sfixed32(), this.sfixed32()); + } + /** + * Read a `float` field, 32-bit floating point number. + */ + float() { + return this.view.getFloat32((this.pos += 4) - 4, true); + } + /** + * Read a `double` field, a 64-bit floating point number. + */ + double() { + return this.view.getFloat64((this.pos += 8) - 8, true); + } + /** + * Read a `bytes` field, length-delimited arbitrary data. + */ + bytes() { + let len = this.uint32(), + start = this.pos; + this.pos += len; + this.assertBounds(); + return this.buf.subarray(start, start + len); + } + /** + * Read a `string` field, length-delimited data converted to UTF-8 text. + */ + string() { + return this.textDecoder.decode(this.bytes()); + } +}; + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/extensions.js +function makeExtension(runtime, typeName, extendee, field) { + let fi; + return { + typeName, + extendee, + get field() { + if (!fi) { + const i = typeof field == 'function' ? field() : field; + i.name = typeName.split('.').pop(); + i.jsonName = `[${typeName}]`; + fi = runtime.util.newFieldList([i]).list()[0]; + } + return fi; + }, + runtime, + }; +} +function createExtensionContainer(extension) { + const localName = extension.field.localName; + const container = /* @__PURE__ */ Object.create(null); + container[localName] = initExtensionField(extension); + return [container, () => container[localName]]; +} +function initExtensionField(ext) { + const field = ext.field; + if (field.repeated) { + return []; + } + if (field.default !== void 0) { + return field.default; + } + switch (field.kind) { + case 'enum': + return field.T.values[0].no; + case 'scalar': + return scalarZeroValue(field.T, field.L); + case 'message': + const T = field.T, + value = new T(); + return T.fieldWrapper ? T.fieldWrapper.unwrapField(value) : value; + case 'map': + throw 'map fields are not allowed to be extensions'; + } +} +function filterUnknownFields(unknownFields, field) { + if (!field.repeated && (field.kind == 'enum' || field.kind == 'scalar')) { + for (let i = unknownFields.length - 1; i >= 0; --i) { + if (unknownFields[i].no == field.no) { + return [unknownFields[i]]; + } + } + return []; + } + return unknownFields.filter((uf) => uf.no === field.no); +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/proto-base64.js +var encTable = + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split(''); +var decTable = []; +for (let i = 0; i < encTable.length; i++) + decTable[encTable[i].charCodeAt(0)] = i; +decTable['-'.charCodeAt(0)] = encTable.indexOf('+'); +decTable['_'.charCodeAt(0)] = encTable.indexOf('/'); +var protoBase64 = { + /** + * Decodes a base64 string to a byte array. + * + * - ignores white-space, including line breaks and tabs + * - allows inner padding (can decode concatenated base64 strings) + * - does not require padding + * - understands base64url encoding: + * "-" instead of "+", + * "_" instead of "/", + * no padding + */ + dec(base64Str) { + let es = (base64Str.length * 3) / 4; + if (base64Str[base64Str.length - 2] == '=') es -= 2; + else if (base64Str[base64Str.length - 1] == '=') es -= 1; + let bytes = new Uint8Array(es), + bytePos = 0, + groupPos = 0, + b, + p = 0; + for (let i = 0; i < base64Str.length; i++) { + b = decTable[base64Str.charCodeAt(i)]; + if (b === void 0) { + switch (base64Str[i]) { + // @ts-ignore TS7029: Fallthrough case in switch + case '=': + groupPos = 0; + // reset state when padding found + // @ts-ignore TS7029: Fallthrough case in switch + case '\n': + case '\r': + case ' ': + case ' ': + continue; + // skip white-space, and padding + default: + throw Error('invalid base64 string.'); + } + } + switch (groupPos) { + case 0: + p = b; + groupPos = 1; + break; + case 1: + bytes[bytePos++] = (p << 2) | ((b & 48) >> 4); + p = b; + groupPos = 2; + break; + case 2: + bytes[bytePos++] = ((p & 15) << 4) | ((b & 60) >> 2); + p = b; + groupPos = 3; + break; + case 3: + bytes[bytePos++] = ((p & 3) << 6) | b; + groupPos = 0; + break; + } + } + if (groupPos == 1) throw Error('invalid base64 string.'); + return bytes.subarray(0, bytePos); + }, + /** + * Encode a byte array to a base64 string. + */ + enc(bytes) { + let base64 = '', + groupPos = 0, + b, + p = 0; + for (let i = 0; i < bytes.length; i++) { + b = bytes[i]; + switch (groupPos) { + case 0: + base64 += encTable[b >> 2]; + p = (b & 3) << 4; + groupPos = 1; + break; + case 1: + base64 += encTable[p | (b >> 4)]; + p = (b & 15) << 2; + groupPos = 2; + break; + case 2: + base64 += encTable[p | (b >> 6)]; + base64 += encTable[b & 63]; + groupPos = 0; + break; + } + } + if (groupPos) { + base64 += encTable[p]; + base64 += '='; + if (groupPos == 1) base64 += '='; + } + return base64; + }, +}; + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/extension-accessor.js +function getExtension(message, extension, options) { + assertExtendee(extension, message); + const opt = extension.runtime.bin.makeReadOptions(options); + const ufs = filterUnknownFields( + message.getType().runtime.bin.listUnknownFields(message), + extension.field, + ); + const [container, get] = createExtensionContainer(extension); + for (const uf of ufs) { + extension.runtime.bin.readField( + container, + opt.readerFactory(uf.data), + extension.field, + uf.wireType, + opt, + ); + } + return get(); +} +function setExtension(message, extension, value, options) { + assertExtendee(extension, message); + const readOpt = extension.runtime.bin.makeReadOptions(options); + const writeOpt = extension.runtime.bin.makeWriteOptions(options); + if (hasExtension(message, extension)) { + const ufs = message + .getType() + .runtime.bin.listUnknownFields(message) + .filter((uf) => uf.no != extension.field.no); + message.getType().runtime.bin.discardUnknownFields(message); + for (const uf of ufs) { + message + .getType() + .runtime.bin.onUnknownField(message, uf.no, uf.wireType, uf.data); + } + } + const writer = writeOpt.writerFactory(); + let f = extension.field; + if (!f.opt && !f.repeated && (f.kind == 'enum' || f.kind == 'scalar')) { + f = Object.assign(Object.assign({}, extension.field), { opt: true }); + } + extension.runtime.bin.writeField(f, value, writer, writeOpt); + const reader = readOpt.readerFactory(writer.finish()); + while (reader.pos < reader.len) { + const [no, wireType] = reader.tag(); + const data = reader.skip(wireType); + message.getType().runtime.bin.onUnknownField(message, no, wireType, data); + } +} +function hasExtension(message, extension) { + const messageType = message.getType(); + return ( + extension.extendee.typeName === messageType.typeName && + !!messageType.runtime.bin + .listUnknownFields(message) + .find((uf) => uf.no == extension.field.no) + ); +} +function assertExtendee(extension, message) { + assert( + extension.extendee.typeName == message.getType().typeName, + `extension ${extension.typeName} can only be applied to message ${extension.extendee.typeName}`, + ); +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/reflect.js +function isFieldSet(field, target) { + const localName = field.localName; + if (field.repeated) { + return target[localName].length > 0; + } + if (field.oneof) { + return target[field.oneof.localName].case === localName; + } + switch (field.kind) { + case 'enum': + case 'scalar': + if (field.opt || field.req) { + return target[localName] !== void 0; + } + if (field.kind == 'enum') { + return target[localName] !== field.T.values[0].no; + } + return !isScalarZeroValue(field.T, target[localName]); + case 'message': + return target[localName] !== void 0; + case 'map': + return Object.keys(target[localName]).length > 0; + } +} +function clearField(field, target) { + const localName = field.localName; + const implicitPresence = !field.opt && !field.req; + if (field.repeated) { + target[localName] = []; + } else if (field.oneof) { + target[field.oneof.localName] = { case: void 0 }; + } else { + switch (field.kind) { + case 'map': + target[localName] = {}; + break; + case 'enum': + target[localName] = implicitPresence ? field.T.values[0].no : void 0; + break; + case 'scalar': + target[localName] = implicitPresence + ? scalarZeroValue(field.T, field.L) + : void 0; + break; + case 'message': + target[localName] = void 0; + break; + } + } +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/is-message.js +function isMessage(arg, type) { + if (arg === null || typeof arg != 'object') { + return false; + } + if ( + !Object.getOwnPropertyNames(Message.prototype).every( + (m) => m in arg && typeof arg[m] == 'function', + ) + ) { + return false; + } + const actualType = arg.getType(); + if ( + actualType === null || + typeof actualType != 'function' || + !('typeName' in actualType) || + typeof actualType.typeName != 'string' + ) { + return false; + } + return type === void 0 ? true : actualType.typeName == type.typeName; +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/field-wrapper.js +function wrapField(type, value) { + if (isMessage(value) || !type.fieldWrapper) { + return value; + } + return type.fieldWrapper.wrapField(value); +} +var wktWrapperToScalarType = { + 'google.protobuf.DoubleValue': ScalarType.DOUBLE, + 'google.protobuf.FloatValue': ScalarType.FLOAT, + 'google.protobuf.Int64Value': ScalarType.INT64, + 'google.protobuf.UInt64Value': ScalarType.UINT64, + 'google.protobuf.Int32Value': ScalarType.INT32, + 'google.protobuf.UInt32Value': ScalarType.UINT32, + 'google.protobuf.BoolValue': ScalarType.BOOL, + 'google.protobuf.StringValue': ScalarType.STRING, + 'google.protobuf.BytesValue': ScalarType.BYTES, +}; + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/json-format.js +var jsonReadDefaults = { + ignoreUnknownFields: false, +}; +var jsonWriteDefaults = { + emitDefaultValues: false, + enumAsInteger: false, + useProtoFieldName: false, + prettySpaces: 0, +}; +function makeReadOptions(options) { + return options + ? Object.assign(Object.assign({}, jsonReadDefaults), options) + : jsonReadDefaults; +} +function makeWriteOptions(options) { + return options + ? Object.assign(Object.assign({}, jsonWriteDefaults), options) + : jsonWriteDefaults; +} +var tokenNull = /* @__PURE__ */ Symbol(); +var tokenIgnoredUnknownEnum = /* @__PURE__ */ Symbol(); +function makeJsonFormat() { + return { + makeReadOptions, + makeWriteOptions, + readMessage(type, json, options, message) { + if (json == null || Array.isArray(json) || typeof json != 'object') { + throw new Error( + `cannot decode message ${type.typeName} from JSON: ${debugJsonValue(json)}`, + ); + } + message = message !== null && message !== void 0 ? message : new type(); + const oneofSeen = /* @__PURE__ */ new Map(); + const registry = options.typeRegistry; + for (const [jsonKey, jsonValue] of Object.entries(json)) { + const field = type.fields.findJsonName(jsonKey); + if (field) { + if (field.oneof) { + if (jsonValue === null && field.kind == 'scalar') { + continue; + } + const seen = oneofSeen.get(field.oneof); + if (seen !== void 0) { + throw new Error( + `cannot decode message ${type.typeName} from JSON: multiple keys for oneof "${field.oneof.name}" present: "${seen}", "${jsonKey}"`, + ); + } + oneofSeen.set(field.oneof, jsonKey); + } + readField(message, jsonValue, field, options, type); + } else { + let found = false; + if ( + (registry === null || registry === void 0 + ? void 0 + : registry.findExtension) && + jsonKey.startsWith('[') && + jsonKey.endsWith(']') + ) { + const ext = registry.findExtension( + jsonKey.substring(1, jsonKey.length - 1), + ); + if (ext && ext.extendee.typeName == type.typeName) { + found = true; + const [container, get] = createExtensionContainer(ext); + readField(container, jsonValue, ext.field, options, ext); + setExtension(message, ext, get(), options); + } + } + if (!found && !options.ignoreUnknownFields) { + throw new Error( + `cannot decode message ${type.typeName} from JSON: key "${jsonKey}" is unknown`, + ); + } + } + } + return message; + }, + writeMessage(message, options) { + const type = message.getType(); + const json = {}; + let field; + try { + for (field of type.fields.byNumber()) { + if (!isFieldSet(field, message)) { + if (field.req) { + throw `required field not set`; + } + if (!options.emitDefaultValues) { + continue; + } + if (!canEmitFieldDefaultValue(field)) { + continue; + } + } + const value = field.oneof + ? message[field.oneof.localName].value + : message[field.localName]; + const jsonValue = writeField(field, value, options); + if (jsonValue !== void 0) { + json[options.useProtoFieldName ? field.name : field.jsonName] = + jsonValue; + } + } + const registry = options.typeRegistry; + if ( + registry === null || registry === void 0 + ? void 0 + : registry.findExtensionFor + ) { + for (const uf of type.runtime.bin.listUnknownFields(message)) { + const ext = registry.findExtensionFor(type.typeName, uf.no); + if (ext && hasExtension(message, ext)) { + const value = getExtension(message, ext, options); + const jsonValue = writeField(ext.field, value, options); + if (jsonValue !== void 0) { + json[ext.field.jsonName] = jsonValue; + } + } + } + } + } catch (e) { + const m = field + ? `cannot encode field ${type.typeName}.${field.name} to JSON` + : `cannot encode message ${type.typeName} to JSON`; + const r = e instanceof Error ? e.message : String(e); + throw new Error(m + (r.length > 0 ? `: ${r}` : '')); + } + return json; + }, + readScalar(type, json, longType) { + return readScalar( + type, + json, + longType !== null && longType !== void 0 ? longType : LongType.BIGINT, + true, + ); + }, + writeScalar(type, value, emitDefaultValues) { + if (value === void 0) { + return void 0; + } + if (emitDefaultValues || isScalarZeroValue(type, value)) { + return writeScalar(type, value); + } + return void 0; + }, + debug: debugJsonValue, + }; +} +function debugJsonValue(json) { + if (json === null) { + return 'null'; + } + switch (typeof json) { + case 'object': + return Array.isArray(json) ? 'array' : 'object'; + case 'string': + return json.length > 100 ? 'string' : `"${json.split('"').join('\\"')}"`; + default: + return String(json); + } +} +function readField(target, jsonValue, field, options, parentType) { + let localName = field.localName; + if (field.repeated) { + assert(field.kind != 'map'); + if (jsonValue === null) { + return; + } + if (!Array.isArray(jsonValue)) { + throw new Error( + `cannot decode field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`, + ); + } + const targetArray = target[localName]; + for (const jsonItem of jsonValue) { + if (jsonItem === null) { + throw new Error( + `cannot decode field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonItem)}`, + ); + } + switch (field.kind) { + case 'message': + targetArray.push(field.T.fromJson(jsonItem, options)); + break; + case 'enum': + const enumValue = readEnum( + field.T, + jsonItem, + options.ignoreUnknownFields, + true, + ); + if (enumValue !== tokenIgnoredUnknownEnum) { + targetArray.push(enumValue); + } + break; + case 'scalar': + try { + targetArray.push(readScalar(field.T, jsonItem, field.L, true)); + } catch (e) { + let m = `cannot decode field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonItem)}`; + if (e instanceof Error && e.message.length > 0) { + m += `: ${e.message}`; + } + throw new Error(m); + } + break; + } + } + } else if (field.kind == 'map') { + if (jsonValue === null) { + return; + } + if (typeof jsonValue != 'object' || Array.isArray(jsonValue)) { + throw new Error( + `cannot decode field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`, + ); + } + const targetMap = target[localName]; + for (const [jsonMapKey, jsonMapValue] of Object.entries(jsonValue)) { + if (jsonMapValue === null) { + throw new Error( + `cannot decode field ${parentType.typeName}.${field.name} from JSON: map value null`, + ); + } + let key; + try { + key = readMapKey(field.K, jsonMapKey); + } catch (e) { + let m = `cannot decode map key for field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`; + if (e instanceof Error && e.message.length > 0) { + m += `: ${e.message}`; + } + throw new Error(m); + } + switch (field.V.kind) { + case 'message': + targetMap[key] = field.V.T.fromJson(jsonMapValue, options); + break; + case 'enum': + const enumValue = readEnum( + field.V.T, + jsonMapValue, + options.ignoreUnknownFields, + true, + ); + if (enumValue !== tokenIgnoredUnknownEnum) { + targetMap[key] = enumValue; + } + break; + case 'scalar': + try { + targetMap[key] = readScalar( + field.V.T, + jsonMapValue, + LongType.BIGINT, + true, + ); + } catch (e) { + let m = `cannot decode map value for field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`; + if (e instanceof Error && e.message.length > 0) { + m += `: ${e.message}`; + } + throw new Error(m); + } + break; + } + } + } else { + if (field.oneof) { + target = target[field.oneof.localName] = { case: localName }; + localName = 'value'; + } + switch (field.kind) { + case 'message': + const messageType = field.T; + if ( + jsonValue === null && + messageType.typeName != 'google.protobuf.Value' + ) { + return; + } + let currentValue = target[localName]; + if (isMessage(currentValue)) { + currentValue.fromJson(jsonValue, options); + } else { + target[localName] = currentValue = messageType.fromJson( + jsonValue, + options, + ); + if (messageType.fieldWrapper && !field.oneof) { + target[localName] = + messageType.fieldWrapper.unwrapField(currentValue); + } + } + break; + case 'enum': + const enumValue = readEnum( + field.T, + jsonValue, + options.ignoreUnknownFields, + false, + ); + switch (enumValue) { + case tokenNull: + clearField(field, target); + break; + case tokenIgnoredUnknownEnum: + break; + default: + target[localName] = enumValue; + break; + } + break; + case 'scalar': + try { + const scalarValue = readScalar(field.T, jsonValue, field.L, false); + switch (scalarValue) { + case tokenNull: + clearField(field, target); + break; + default: + target[localName] = scalarValue; + break; + } + } catch (e) { + let m = `cannot decode field ${parentType.typeName}.${field.name} from JSON: ${debugJsonValue(jsonValue)}`; + if (e instanceof Error && e.message.length > 0) { + m += `: ${e.message}`; + } + throw new Error(m); + } + break; + } + } +} +function readMapKey(type, json) { + if (type === ScalarType.BOOL) { + switch (json) { + case 'true': + json = true; + break; + case 'false': + json = false; + break; + } + } + return readScalar(type, json, LongType.BIGINT, true).toString(); +} +function readScalar(type, json, longType, nullAsZeroValue) { + if (json === null) { + if (nullAsZeroValue) { + return scalarZeroValue(type, longType); + } + return tokenNull; + } + switch (type) { + // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity". + // Either numbers or strings are accepted. Exponent notation is also accepted. + case ScalarType.DOUBLE: + case ScalarType.FLOAT: + if (json === 'NaN') return Number.NaN; + if (json === 'Infinity') return Number.POSITIVE_INFINITY; + if (json === '-Infinity') return Number.NEGATIVE_INFINITY; + if (json === '') { + break; + } + if (typeof json == 'string' && json.trim().length !== json.length) { + break; + } + if (typeof json != 'string' && typeof json != 'number') { + break; + } + const float = Number(json); + if (Number.isNaN(float)) { + break; + } + if (!Number.isFinite(float)) { + break; + } + if (type == ScalarType.FLOAT) assertFloat32(float); + return float; + // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted. + case ScalarType.INT32: + case ScalarType.FIXED32: + case ScalarType.SFIXED32: + case ScalarType.SINT32: + case ScalarType.UINT32: + let int32; + if (typeof json == 'number') int32 = json; + else if (typeof json == 'string' && json.length > 0) { + if (json.trim().length === json.length) int32 = Number(json); + } + if (int32 === void 0) break; + if (type == ScalarType.UINT32 || type == ScalarType.FIXED32) + assertUInt32(int32); + else assertInt32(int32); + return int32; + // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted. + case ScalarType.INT64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + if (typeof json != 'number' && typeof json != 'string') break; + const long = protoInt64.parse(json); + return longType ? long.toString() : long; + case ScalarType.FIXED64: + case ScalarType.UINT64: + if (typeof json != 'number' && typeof json != 'string') break; + const uLong = protoInt64.uParse(json); + return longType ? uLong.toString() : uLong; + // bool: + case ScalarType.BOOL: + if (typeof json !== 'boolean') break; + return json; + // string: + case ScalarType.STRING: + if (typeof json !== 'string') { + break; + } + try { + encodeURIComponent(json); + } catch (e) { + throw new Error('invalid UTF8'); + } + return json; + // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings. + // Either standard or URL-safe base64 encoding with/without paddings are accepted. + case ScalarType.BYTES: + if (json === '') return new Uint8Array(0); + if (typeof json !== 'string') break; + return protoBase64.dec(json); + } + throw new Error(); +} +function readEnum(type, json, ignoreUnknownFields, nullAsZeroValue) { + if (json === null) { + if (type.typeName == 'google.protobuf.NullValue') { + return 0; + } + return nullAsZeroValue ? type.values[0].no : tokenNull; + } + switch (typeof json) { + case 'number': + if (Number.isInteger(json)) { + return json; + } + break; + case 'string': + const value = type.findName(json); + if (value !== void 0) { + return value.no; + } + if (ignoreUnknownFields) { + return tokenIgnoredUnknownEnum; + } + break; + } + throw new Error( + `cannot decode enum ${type.typeName} from JSON: ${debugJsonValue(json)}`, + ); +} +function canEmitFieldDefaultValue(field) { + if (field.repeated || field.kind == 'map') { + return true; + } + if (field.oneof) { + return false; + } + if (field.kind == 'message') { + return false; + } + if (field.opt || field.req) { + return false; + } + return true; +} +function writeField(field, value, options) { + if (field.kind == 'map') { + assert(typeof value == 'object' && value != null); + const jsonObj = {}; + const entries = Object.entries(value); + switch (field.V.kind) { + case 'scalar': + for (const [entryKey, entryValue] of entries) { + jsonObj[entryKey.toString()] = writeScalar(field.V.T, entryValue); + } + break; + case 'message': + for (const [entryKey, entryValue] of entries) { + jsonObj[entryKey.toString()] = entryValue.toJson(options); + } + break; + case 'enum': + const enumType = field.V.T; + for (const [entryKey, entryValue] of entries) { + jsonObj[entryKey.toString()] = writeEnum( + enumType, + entryValue, + options.enumAsInteger, + ); + } + break; + } + return options.emitDefaultValues || entries.length > 0 ? jsonObj : void 0; + } + if (field.repeated) { + assert(Array.isArray(value)); + const jsonArr = []; + switch (field.kind) { + case 'scalar': + for (let i = 0; i < value.length; i++) { + jsonArr.push(writeScalar(field.T, value[i])); + } + break; + case 'enum': + for (let i = 0; i < value.length; i++) { + jsonArr.push(writeEnum(field.T, value[i], options.enumAsInteger)); + } + break; + case 'message': + for (let i = 0; i < value.length; i++) { + jsonArr.push(value[i].toJson(options)); + } + break; + } + return options.emitDefaultValues || jsonArr.length > 0 ? jsonArr : void 0; + } + switch (field.kind) { + case 'scalar': + return writeScalar(field.T, value); + case 'enum': + return writeEnum(field.T, value, options.enumAsInteger); + case 'message': + return wrapField(field.T, value).toJson(options); + } +} +function writeEnum(type, value, enumAsInteger) { + var _a; + assert(typeof value == 'number'); + if (type.typeName == 'google.protobuf.NullValue') { + return null; + } + if (enumAsInteger) { + return value; + } + const val = type.findNumber(value); + return (_a = val === null || val === void 0 ? void 0 : val.name) !== null && + _a !== void 0 + ? _a + : value; +} +function writeScalar(type, value) { + switch (type) { + // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted. + case ScalarType.INT32: + case ScalarType.SFIXED32: + case ScalarType.SINT32: + case ScalarType.FIXED32: + case ScalarType.UINT32: + assert(typeof value == 'number'); + return value; + // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity". + // Either numbers or strings are accepted. Exponent notation is also accepted. + case ScalarType.FLOAT: + // assertFloat32(value); + case ScalarType.DOUBLE: + assert(typeof value == 'number'); + if (Number.isNaN(value)) return 'NaN'; + if (value === Number.POSITIVE_INFINITY) return 'Infinity'; + if (value === Number.NEGATIVE_INFINITY) return '-Infinity'; + return value; + // string: + case ScalarType.STRING: + assert(typeof value == 'string'); + return value; + // bool: + case ScalarType.BOOL: + assert(typeof value == 'boolean'); + return value; + // JSON value will be a decimal string. Either numbers or strings are accepted. + case ScalarType.UINT64: + case ScalarType.FIXED64: + case ScalarType.INT64: + case ScalarType.SFIXED64: + case ScalarType.SINT64: + assert( + typeof value == 'bigint' || + typeof value == 'string' || + typeof value == 'number', + ); + return value.toString(); + // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings. + // Either standard or URL-safe base64 encoding with/without paddings are accepted. + case ScalarType.BYTES: + assert(value instanceof Uint8Array); + return protoBase64.enc(value); + } +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/binary-format.js +var unknownFieldsSymbol = /* @__PURE__ */ Symbol( + '@bufbuild/protobuf/unknown-fields', +); +var readDefaults = { + readUnknownFields: true, + readerFactory: (bytes) => new BinaryReader(bytes), +}; +var writeDefaults = { + writeUnknownFields: true, + writerFactory: () => new BinaryWriter(), +}; +function makeReadOptions2(options) { + return options + ? Object.assign(Object.assign({}, readDefaults), options) + : readDefaults; +} +function makeWriteOptions2(options) { + return options + ? Object.assign(Object.assign({}, writeDefaults), options) + : writeDefaults; +} +function makeBinaryFormat() { + return { + makeReadOptions: makeReadOptions2, + makeWriteOptions: makeWriteOptions2, + listUnknownFields(message) { + var _a; + return (_a = message[unknownFieldsSymbol]) !== null && _a !== void 0 + ? _a + : []; + }, + discardUnknownFields(message) { + delete message[unknownFieldsSymbol]; + }, + writeUnknownFields(message, writer) { + const m = message; + const c = m[unknownFieldsSymbol]; + if (c) { + for (const f of c) { + writer.tag(f.no, f.wireType).raw(f.data); + } + } + }, + onUnknownField(message, no, wireType, data) { + const m = message; + if (!Array.isArray(m[unknownFieldsSymbol])) { + m[unknownFieldsSymbol] = []; + } + m[unknownFieldsSymbol].push({ no, wireType, data }); + }, + readMessage( + message, + reader, + lengthOrEndTagFieldNo, + options, + delimitedMessageEncoding, + ) { + const type = message.getType(); + const end = delimitedMessageEncoding + ? reader.len + : reader.pos + lengthOrEndTagFieldNo; + let fieldNo, wireType; + while (reader.pos < end) { + [fieldNo, wireType] = reader.tag(); + if (wireType == WireType.EndGroup) { + break; + } + const field = type.fields.find(fieldNo); + if (!field) { + const data = reader.skip(wireType); + if (options.readUnknownFields) { + this.onUnknownField(message, fieldNo, wireType, data); + } + continue; + } + readField2(message, reader, field, wireType, options); + } + if ( + delimitedMessageEncoding && // eslint-disable-line @typescript-eslint/strict-boolean-expressions + (wireType != WireType.EndGroup || fieldNo !== lengthOrEndTagFieldNo) + ) { + throw new Error(`invalid end group tag`); + } + }, + readField: readField2, + writeMessage(message, writer, options) { + const type = message.getType(); + for (const field of type.fields.byNumber()) { + if (!isFieldSet(field, message)) { + if (field.req) { + throw new Error( + `cannot encode field ${type.typeName}.${field.name} to binary: required field not set`, + ); + } + continue; + } + const value = field.oneof + ? message[field.oneof.localName].value + : message[field.localName]; + writeField2(field, value, writer, options); + } + if (options.writeUnknownFields) { + this.writeUnknownFields(message, writer); + } + return writer; + }, + writeField(field, value, writer, options) { + if (value === void 0) { + return void 0; + } + writeField2(field, value, writer, options); + }, + }; +} +function readField2(target, reader, field, wireType, options) { + let { repeated, localName } = field; + if (field.oneof) { + target = target[field.oneof.localName]; + if (target.case != localName) { + delete target.value; + } + target.case = localName; + localName = 'value'; + } + switch (field.kind) { + case 'scalar': + case 'enum': + const scalarType = field.kind == 'enum' ? ScalarType.INT32 : field.T; + let read = readScalar2; + if (field.kind == 'scalar' && field.L > 0) { + read = readScalarLTString; + } + if (repeated) { + let arr = target[localName]; + const isPacked = + wireType == WireType.LengthDelimited && + scalarType != ScalarType.STRING && + scalarType != ScalarType.BYTES; + if (isPacked) { + let e = reader.uint32() + reader.pos; + while (reader.pos < e) { + arr.push(read(reader, scalarType)); + } + } else { + arr.push(read(reader, scalarType)); + } + } else { + target[localName] = read(reader, scalarType); + } + break; + case 'message': + const messageType = field.T; + if (repeated) { + target[localName].push( + readMessageField(reader, new messageType(), options, field), + ); + } else { + if (isMessage(target[localName])) { + readMessageField(reader, target[localName], options, field); + } else { + target[localName] = readMessageField( + reader, + new messageType(), + options, + field, + ); + if (messageType.fieldWrapper && !field.oneof && !field.repeated) { + target[localName] = messageType.fieldWrapper.unwrapField( + target[localName], + ); + } + } + } + break; + case 'map': + let [mapKey, mapVal] = readMapEntry(field, reader, options); + target[localName][mapKey] = mapVal; + break; + } +} +function readMessageField(reader, message, options, field) { + const format = message.getType().runtime.bin; + const delimited = + field === null || field === void 0 ? void 0 : field.delimited; + format.readMessage( + message, + reader, + delimited ? field.no : reader.uint32(), + // eslint-disable-line @typescript-eslint/strict-boolean-expressions + options, + delimited, + ); + return message; +} +function readMapEntry(field, reader, options) { + const length = reader.uint32(), + end = reader.pos + length; + let key, val; + while (reader.pos < end) { + const [fieldNo] = reader.tag(); + switch (fieldNo) { + case 1: + key = readScalar2(reader, field.K); + break; + case 2: + switch (field.V.kind) { + case 'scalar': + val = readScalar2(reader, field.V.T); + break; + case 'enum': + val = reader.int32(); + break; + case 'message': + val = readMessageField(reader, new field.V.T(), options, void 0); + break; + } + break; + } + } + if (key === void 0) { + key = scalarZeroValue(field.K, LongType.BIGINT); + } + if (typeof key != 'string' && typeof key != 'number') { + key = key.toString(); + } + if (val === void 0) { + switch (field.V.kind) { + case 'scalar': + val = scalarZeroValue(field.V.T, LongType.BIGINT); + break; + case 'enum': + val = field.V.T.values[0].no; + break; + case 'message': + val = new field.V.T(); + break; + } + } + return [key, val]; +} +function readScalarLTString(reader, type) { + const v = readScalar2(reader, type); + return typeof v == 'bigint' ? v.toString() : v; +} +function readScalar2(reader, type) { + switch (type) { + case ScalarType.STRING: + return reader.string(); + case ScalarType.BOOL: + return reader.bool(); + case ScalarType.DOUBLE: + return reader.double(); + case ScalarType.FLOAT: + return reader.float(); + case ScalarType.INT32: + return reader.int32(); + case ScalarType.INT64: + return reader.int64(); + case ScalarType.UINT64: + return reader.uint64(); + case ScalarType.FIXED64: + return reader.fixed64(); + case ScalarType.BYTES: + return reader.bytes(); + case ScalarType.FIXED32: + return reader.fixed32(); + case ScalarType.SFIXED32: + return reader.sfixed32(); + case ScalarType.SFIXED64: + return reader.sfixed64(); + case ScalarType.SINT64: + return reader.sint64(); + case ScalarType.UINT32: + return reader.uint32(); + case ScalarType.SINT32: + return reader.sint32(); + } +} +function writeField2(field, value, writer, options) { + assert(value !== void 0); + const repeated = field.repeated; + switch (field.kind) { + case 'scalar': + case 'enum': + let scalarType = field.kind == 'enum' ? ScalarType.INT32 : field.T; + if (repeated) { + assert(Array.isArray(value)); + if (field.packed) { + writePacked(writer, scalarType, field.no, value); + } else { + for (const item of value) { + writeScalar2(writer, scalarType, field.no, item); + } + } + } else { + writeScalar2(writer, scalarType, field.no, value); + } + break; + case 'message': + if (repeated) { + assert(Array.isArray(value)); + for (const item of value) { + writeMessageField(writer, options, field, item); + } + } else { + writeMessageField(writer, options, field, value); + } + break; + case 'map': + assert(typeof value == 'object' && value != null); + for (const [key, val] of Object.entries(value)) { + writeMapEntry(writer, options, field, key, val); + } + break; + } +} +function writeMapEntry(writer, options, field, key, value) { + writer.tag(field.no, WireType.LengthDelimited); + writer.fork(); + let keyValue = key; + switch (field.K) { + case ScalarType.INT32: + case ScalarType.FIXED32: + case ScalarType.UINT32: + case ScalarType.SFIXED32: + case ScalarType.SINT32: + keyValue = Number.parseInt(key); + break; + case ScalarType.BOOL: + assert(key == 'true' || key == 'false'); + keyValue = key == 'true'; + break; + } + writeScalar2(writer, field.K, 1, keyValue); + switch (field.V.kind) { + case 'scalar': + writeScalar2(writer, field.V.T, 2, value); + break; + case 'enum': + writeScalar2(writer, ScalarType.INT32, 2, value); + break; + case 'message': + assert(value !== void 0); + writer.tag(2, WireType.LengthDelimited).bytes(value.toBinary(options)); + break; + } + writer.join(); +} +function writeMessageField(writer, options, field, value) { + const message = wrapField(field.T, value); + if (field.delimited) + writer + .tag(field.no, WireType.StartGroup) + .raw(message.toBinary(options)) + .tag(field.no, WireType.EndGroup); + else + writer + .tag(field.no, WireType.LengthDelimited) + .bytes(message.toBinary(options)); +} +function writeScalar2(writer, type, fieldNo, value) { + assert(value !== void 0); + let [wireType, method] = scalarTypeInfo(type); + writer.tag(fieldNo, wireType)[method](value); +} +function writePacked(writer, type, fieldNo, value) { + if (!value.length) { + return; + } + writer.tag(fieldNo, WireType.LengthDelimited).fork(); + let [, method] = scalarTypeInfo(type); + for (let i = 0; i < value.length; i++) { + writer[method](value[i]); + } + writer.join(); +} +function scalarTypeInfo(type) { + let wireType = WireType.Varint; + switch (type) { + case ScalarType.BYTES: + case ScalarType.STRING: + wireType = WireType.LengthDelimited; + break; + case ScalarType.DOUBLE: + case ScalarType.FIXED64: + case ScalarType.SFIXED64: + wireType = WireType.Bit64; + break; + case ScalarType.FIXED32: + case ScalarType.SFIXED32: + case ScalarType.FLOAT: + wireType = WireType.Bit32; + break; + } + const method = ScalarType[type].toLowerCase(); + return [wireType, method]; +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/util-common.js +function makeUtilCommon() { + return { + setEnumType, + initPartial(source, target) { + if (source === void 0) { + return; + } + const type = target.getType(); + for (const member of type.fields.byMember()) { + const localName = member.localName, + t = target, + s = source; + if (s[localName] === void 0) { + continue; + } + switch (member.kind) { + case 'oneof': + const sk = s[localName].case; + if (sk === void 0) { + continue; + } + const sourceField = member.findField(sk); + let val = s[localName].value; + if ( + sourceField && + sourceField.kind == 'message' && + !isMessage(val, sourceField.T) + ) { + val = new sourceField.T(val); + } else if ( + sourceField && + sourceField.kind === 'scalar' && + sourceField.T === ScalarType.BYTES + ) { + val = toU8Arr(val); + } + t[localName] = { case: sk, value: val }; + break; + case 'scalar': + case 'enum': + let copy = s[localName]; + if (member.T === ScalarType.BYTES) { + copy = member.repeated ? copy.map(toU8Arr) : toU8Arr(copy); + } + t[localName] = copy; + break; + case 'map': + switch (member.V.kind) { + case 'scalar': + case 'enum': + if (member.V.T === ScalarType.BYTES) { + for (const [k, v] of Object.entries(s[localName])) { + t[localName][k] = toU8Arr(v); + } + } else { + Object.assign(t[localName], s[localName]); + } + break; + case 'message': + const messageType = member.V.T; + for (const k of Object.keys(s[localName])) { + let val2 = s[localName][k]; + if (!messageType.fieldWrapper) { + val2 = new messageType(val2); + } + t[localName][k] = val2; + } + break; + } + break; + case 'message': + const mt = member.T; + if (member.repeated) { + t[localName] = s[localName].map((val2) => + isMessage(val2, mt) ? val2 : new mt(val2), + ); + } else { + const val2 = s[localName]; + if (mt.fieldWrapper) { + if ( + // We can't use BytesValue.typeName as that will create a circular import + mt.typeName === 'google.protobuf.BytesValue' + ) { + t[localName] = toU8Arr(val2); + } else { + t[localName] = val2; + } + } else { + t[localName] = isMessage(val2, mt) ? val2 : new mt(val2); + } + } + break; + } + } + }, + // TODO use isFieldSet() here to support future field presence + equals(type, a, b) { + if (a === b) { + return true; + } + if (!a || !b) { + return false; + } + return type.fields.byMember().every((m) => { + const va = a[m.localName]; + const vb = b[m.localName]; + if (m.repeated) { + if (va.length !== vb.length) { + return false; + } + switch (m.kind) { + case 'message': + return va.every((a2, i) => m.T.equals(a2, vb[i])); + case 'scalar': + return va.every((a2, i) => scalarEquals(m.T, a2, vb[i])); + case 'enum': + return va.every((a2, i) => + scalarEquals(ScalarType.INT32, a2, vb[i]), + ); + } + throw new Error(`repeated cannot contain ${m.kind}`); + } + switch (m.kind) { + case 'message': + return m.T.equals(va, vb); + case 'enum': + return scalarEquals(ScalarType.INT32, va, vb); + case 'scalar': + return scalarEquals(m.T, va, vb); + case 'oneof': + if (va.case !== vb.case) { + return false; + } + const s = m.findField(va.case); + if (s === void 0) { + return true; + } + switch (s.kind) { + case 'message': + return s.T.equals(va.value, vb.value); + case 'enum': + return scalarEquals(ScalarType.INT32, va.value, vb.value); + case 'scalar': + return scalarEquals(s.T, va.value, vb.value); + } + throw new Error(`oneof cannot contain ${s.kind}`); + case 'map': + const keys = Object.keys(va).concat(Object.keys(vb)); + switch (m.V.kind) { + case 'message': + const messageType = m.V.T; + return keys.every((k) => messageType.equals(va[k], vb[k])); + case 'enum': + return keys.every((k) => + scalarEquals(ScalarType.INT32, va[k], vb[k]), + ); + case 'scalar': + const scalarType = m.V.T; + return keys.every((k) => + scalarEquals(scalarType, va[k], vb[k]), + ); + } + break; + } + }); + }, + // TODO use isFieldSet() here to support future field presence + clone(message) { + const type = message.getType(), + target = new type(), + any = target; + for (const member of type.fields.byMember()) { + const source = message[member.localName]; + let copy; + if (member.repeated) { + copy = source.map(cloneSingularField); + } else if (member.kind == 'map') { + copy = any[member.localName]; + for (const [key, v] of Object.entries(source)) { + copy[key] = cloneSingularField(v); + } + } else if (member.kind == 'oneof') { + const f = member.findField(source.case); + copy = f + ? { case: source.case, value: cloneSingularField(source.value) } + : { case: void 0 }; + } else { + copy = cloneSingularField(source); + } + any[member.localName] = copy; + } + for (const uf of type.runtime.bin.listUnknownFields(message)) { + type.runtime.bin.onUnknownField(any, uf.no, uf.wireType, uf.data); + } + return target; + }, + }; +} +function cloneSingularField(value) { + if (value === void 0) { + return value; + } + if (isMessage(value)) { + return value.clone(); + } + if (value instanceof Uint8Array) { + const c = new Uint8Array(value.byteLength); + c.set(value); + return c; + } + return value; +} +function toU8Arr(input) { + return input instanceof Uint8Array ? input : new Uint8Array(input); +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/proto-runtime.js +function makeProtoRuntime(syntax, newFieldList, initFields) { + return { + syntax, + json: makeJsonFormat(), + bin: makeBinaryFormat(), + util: Object.assign(Object.assign({}, makeUtilCommon()), { + newFieldList, + initFields, + }), + makeMessageType(typeName, fields, opt) { + return makeMessageType(this, typeName, fields, opt); + }, + makeEnum, + makeEnumType, + getEnumType, + makeExtension(typeName, extendee, field) { + return makeExtension(this, typeName, extendee, field); + }, + }; +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/field-list.js +var InternalFieldList = class { + constructor(fields, normalizer) { + this._fields = fields; + this._normalizer = normalizer; + } + findJsonName(jsonName) { + if (!this.jsonNames) { + const t = {}; + for (const f of this.list()) { + t[f.jsonName] = t[f.name] = f; + } + this.jsonNames = t; + } + return this.jsonNames[jsonName]; + } + find(fieldNo) { + if (!this.numbers) { + const t = {}; + for (const f of this.list()) { + t[f.no] = f; + } + this.numbers = t; + } + return this.numbers[fieldNo]; + } + list() { + if (!this.all) { + this.all = this._normalizer(this._fields); + } + return this.all; + } + byNumber() { + if (!this.numbersAsc) { + this.numbersAsc = this.list() + .concat() + .sort((a, b) => a.no - b.no); + } + return this.numbersAsc; + } + byMember() { + if (!this.members) { + this.members = []; + const a = this.members; + let o; + for (const f of this.list()) { + if (f.oneof) { + if (f.oneof !== o) { + o = f.oneof; + a.push(o); + } + } else { + a.push(f); + } + } + } + return this.members; + } +}; + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/names.js +function localFieldName(protoName, inOneof) { + const name = protoCamelCase(protoName); + if (inOneof) { + return name; + } + return safeObjectProperty(safeMessageProperty(name)); +} +function localOneofName(protoName) { + return localFieldName(protoName, false); +} +var fieldJsonName = protoCamelCase; +function protoCamelCase(snakeCase) { + let capNext = false; + const b = []; + for (let i = 0; i < snakeCase.length; i++) { + let c = snakeCase.charAt(i); + switch (c) { + case '_': + capNext = true; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + b.push(c); + capNext = false; + break; + default: + if (capNext) { + capNext = false; + c = c.toUpperCase(); + } + b.push(c); + break; + } + } + return b.join(''); +} +var reservedObjectProperties = /* @__PURE__ */ new Set([ + // names reserved by JavaScript + 'constructor', + 'toString', + 'toJSON', + 'valueOf', +]); +var reservedMessageProperties = /* @__PURE__ */ new Set([ + // names reserved by the runtime + 'getType', + 'clone', + 'equals', + 'fromBinary', + 'fromJson', + 'fromJsonString', + 'toBinary', + 'toJson', + 'toJsonString', + // names reserved by the runtime for the future + 'toObject', +]); +var fallback = (name) => `${name}$`; +var safeMessageProperty = (name) => { + if (reservedMessageProperties.has(name)) { + return fallback(name); + } + return name; +}; +var safeObjectProperty = (name) => { + if (reservedObjectProperties.has(name)) { + return fallback(name); + } + return name; +}; + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/field.js +var InternalOneofInfo = class { + constructor(name) { + this.kind = 'oneof'; + this.repeated = false; + this.packed = false; + this.opt = false; + this.req = false; + this.default = void 0; + this.fields = []; + this.name = name; + this.localName = localOneofName(name); + } + addField(field) { + assert(field.oneof === this, `field ${field.name} not one of ${this.name}`); + this.fields.push(field); + } + findField(localName) { + if (!this._lookup) { + this._lookup = /* @__PURE__ */ Object.create(null); + for (let i = 0; i < this.fields.length; i++) { + this._lookup[this.fields[i].localName] = this.fields[i]; + } + } + return this._lookup[localName]; + } +}; + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/private/field-normalize.js +function normalizeFieldInfos(fieldInfos, packedByDefault) { + var _a, _b, _c, _d, _e, _f; + const r = []; + let o; + for (const field of typeof fieldInfos == 'function' + ? fieldInfos() + : fieldInfos) { + const f = field; + f.localName = localFieldName(field.name, field.oneof !== void 0); + f.jsonName = + (_a = field.jsonName) !== null && _a !== void 0 + ? _a + : fieldJsonName(field.name); + f.repeated = (_b = field.repeated) !== null && _b !== void 0 ? _b : false; + if (field.kind == 'scalar') { + f.L = (_c = field.L) !== null && _c !== void 0 ? _c : LongType.BIGINT; + } + f.delimited = (_d = field.delimited) !== null && _d !== void 0 ? _d : false; + f.req = (_e = field.req) !== null && _e !== void 0 ? _e : false; + f.opt = (_f = field.opt) !== null && _f !== void 0 ? _f : false; + if (field.packed === void 0) { + if (packedByDefault) { + f.packed = + field.kind == 'enum' || + (field.kind == 'scalar' && + field.T != ScalarType.BYTES && + field.T != ScalarType.STRING); + } else { + f.packed = false; + } + } + if (field.oneof !== void 0) { + const ooname = + typeof field.oneof == 'string' ? field.oneof : field.oneof.name; + if (!o || o.name != ooname) { + o = new InternalOneofInfo(ooname); + } + f.oneof = o; + o.addField(f); + } + r.push(f); + } + return r; +} + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/proto3.js +var proto3 = makeProtoRuntime( + 'proto3', + (fields) => { + return new InternalFieldList(fields, (source) => + normalizeFieldInfos(source, true), + ); + }, + // TODO merge with proto2 and initExtensionField, also see initPartial, equals, clone + (target) => { + for (const member of target.getType().fields.byMember()) { + if (member.opt) { + continue; + } + const name = member.localName, + t = target; + if (member.repeated) { + t[name] = []; + continue; + } + switch (member.kind) { + case 'oneof': + t[name] = { case: void 0 }; + break; + case 'enum': + t[name] = 0; + break; + case 'map': + t[name] = {}; + break; + case 'scalar': + t[name] = scalarZeroValue(member.T, member.L); + break; + case 'message': + break; + } + } + }, +); + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/google/protobuf/timestamp_pb.js +var Timestamp = class _Timestamp extends Message { + constructor(data) { + super(); + this.seconds = protoInt64.zero; + this.nanos = 0; + proto3.util.initPartial(data, this); + } + fromJson(json, options) { + if (typeof json !== 'string') { + throw new Error( + `cannot decode google.protobuf.Timestamp from JSON: ${proto3.json.debug(json)}`, + ); + } + const matches = json.match( + /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/, + ); + if (!matches) { + throw new Error( + `cannot decode google.protobuf.Timestamp from JSON: invalid RFC 3339 string`, + ); + } + const ms = Date.parse( + matches[1] + + '-' + + matches[2] + + '-' + + matches[3] + + 'T' + + matches[4] + + ':' + + matches[5] + + ':' + + matches[6] + + (matches[8] ? matches[8] : 'Z'), + ); + if (Number.isNaN(ms)) { + throw new Error( + `cannot decode google.protobuf.Timestamp from JSON: invalid RFC 3339 string`, + ); + } + if ( + ms < Date.parse('0001-01-01T00:00:00Z') || + ms > Date.parse('9999-12-31T23:59:59Z') + ) { + throw new Error( + `cannot decode message google.protobuf.Timestamp from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`, + ); + } + this.seconds = protoInt64.parse(ms / 1e3); + this.nanos = 0; + if (matches[7]) { + this.nanos = + parseInt('1' + matches[7] + '0'.repeat(9 - matches[7].length)) - 1e9; + } + return this; + } + toJson(options) { + const ms = Number(this.seconds) * 1e3; + if ( + ms < Date.parse('0001-01-01T00:00:00Z') || + ms > Date.parse('9999-12-31T23:59:59Z') + ) { + throw new Error( + `cannot encode google.protobuf.Timestamp to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`, + ); + } + if (this.nanos < 0) { + throw new Error( + `cannot encode google.protobuf.Timestamp to JSON: nanos must not be negative`, + ); + } + let z = 'Z'; + if (this.nanos > 0) { + const nanosStr = (this.nanos + 1e9).toString().substring(1); + if (nanosStr.substring(3) === '000000') { + z = '.' + nanosStr.substring(0, 3) + 'Z'; + } else if (nanosStr.substring(6) === '000') { + z = '.' + nanosStr.substring(0, 6) + 'Z'; + } else { + z = '.' + nanosStr + 'Z'; + } + } + return new Date(ms).toISOString().replace('.000Z', z); + } + toDate() { + return new Date(Number(this.seconds) * 1e3 + Math.ceil(this.nanos / 1e6)); + } + static now() { + return _Timestamp.fromDate(/* @__PURE__ */ new Date()); + } + static fromDate(date) { + const ms = date.getTime(); + return new _Timestamp({ + seconds: protoInt64.parse(Math.floor(ms / 1e3)), + nanos: (ms % 1e3) * 1e6, + }); + } + static fromBinary(bytes, options) { + return new _Timestamp().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Timestamp().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Timestamp().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Timestamp, a, b); + } +}; +Timestamp.runtime = proto3; +Timestamp.typeName = 'google.protobuf.Timestamp'; +Timestamp.fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'seconds', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 2, + name: 'nanos', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, +]); + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/google/protobuf/duration_pb.js +var Duration = class _Duration extends Message { + constructor(data) { + super(); + this.seconds = protoInt64.zero; + this.nanos = 0; + proto3.util.initPartial(data, this); + } + fromJson(json, options) { + if (typeof json !== 'string') { + throw new Error( + `cannot decode google.protobuf.Duration from JSON: ${proto3.json.debug(json)}`, + ); + } + const match = json.match(/^(-?[0-9]+)(?:\.([0-9]+))?s/); + if (match === null) { + throw new Error( + `cannot decode google.protobuf.Duration from JSON: ${proto3.json.debug(json)}`, + ); + } + const longSeconds = Number(match[1]); + if (longSeconds > 315576e6 || longSeconds < -315576e6) { + throw new Error( + `cannot decode google.protobuf.Duration from JSON: ${proto3.json.debug(json)}`, + ); + } + this.seconds = protoInt64.parse(longSeconds); + if (typeof match[2] == 'string') { + const nanosStr = match[2] + '0'.repeat(9 - match[2].length); + this.nanos = parseInt(nanosStr); + if (longSeconds < 0 || Object.is(longSeconds, -0)) { + this.nanos = -this.nanos; + } + } + return this; + } + toJson(options) { + if (Number(this.seconds) > 315576e6 || Number(this.seconds) < -315576e6) { + throw new Error( + `cannot encode google.protobuf.Duration to JSON: value out of range`, + ); + } + let text = this.seconds.toString(); + if (this.nanos !== 0) { + let nanosStr = Math.abs(this.nanos).toString(); + nanosStr = '0'.repeat(9 - nanosStr.length) + nanosStr; + if (nanosStr.substring(3) === '000000') { + nanosStr = nanosStr.substring(0, 3); + } else if (nanosStr.substring(6) === '000') { + nanosStr = nanosStr.substring(0, 6); + } + text += '.' + nanosStr; + if (this.nanos < 0 && Number(this.seconds) == 0) { + text = '-' + text; + } + } + return text + 's'; + } + static fromBinary(bytes, options) { + return new _Duration().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Duration().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Duration().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Duration, a, b); + } +}; +Duration.runtime = proto3; +Duration.typeName = 'google.protobuf.Duration'; +Duration.fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'seconds', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 2, + name: 'nanos', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, +]); + +// exa/proto_ts/node_modules/@bufbuild/protobuf/dist/esm/google/protobuf/empty_pb.js +var Empty = class _Empty extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new _Empty().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Empty().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Empty().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Empty, a, b); + } +}; +Empty.runtime = proto3; +Empty.typeName = 'google.protobuf.Empty'; +Empty.fields = proto3.util.newFieldList(() => []); + +// exa/proto_ts/dist/exa/google/internal/cloud/code/v1internal/credits_pb.js +var Credits = class _Credits extends Message { + /** + * The type of credit that was used to pay for LLM inferences. + * + * @generated from field: google.internal.cloud.code.v1internal.Credits.CreditType credit_type = 1; + */ + creditType = Credits_CreditType.CREDIT_TYPE_UNSPECIFIED; + /** + * The amount of credits. What this number represents depends on the context + * (i.e. credits consumed, credits remaining, etc.) + * + * @generated from field: int64 credit_amount = 2; + */ + creditAmount = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.Credits'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'credit_type', + kind: 'enum', + T: proto3.getEnumType(Credits_CreditType), + }, + { + no: 2, + name: 'credit_amount', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _Credits().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Credits().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Credits().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Credits, a, b); + } +}; +var Credits_CreditType; +(function (Credits_CreditType2) { + Credits_CreditType2[(Credits_CreditType2['CREDIT_TYPE_UNSPECIFIED'] = 0)] = + 'CREDIT_TYPE_UNSPECIFIED'; + Credits_CreditType2[(Credits_CreditType2['GOOGLE_ONE_AI'] = 1)] = + 'GOOGLE_ONE_AI'; +})(Credits_CreditType || (Credits_CreditType = {})); +proto3.util.setEnumType( + Credits_CreditType, + 'google.internal.cloud.code.v1internal.Credits.CreditType', + [ + { no: 0, name: 'CREDIT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'GOOGLE_ONE_AI' }, + ], +); + +// exa/proto_ts/dist/exa/google/internal/cloud/code/v1internal/onboarding_pb.js +var OnboardUserRequest = class _OnboardUserRequest extends Message { + /** + * ID of the tier (see UserTier) that User is attempting to onboard to + * + * @generated from field: string tier_id = 1; + */ + tierId = ''; + /** + * Required if tier has user_defined_cloudaicompanion_project = true. + * + * @generated from field: optional string cloudaicompanion_project = 2; + */ + cloudaicompanionProject; + /** + * Optional metadata provided by clients for mendel diversion. + * + * @generated from field: google.internal.cloud.code.v1internal.ClientMetadata metadata = 3; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.OnboardUserRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'tier_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'cloudaicompanion_project', + kind: 'scalar', + T: 9, + opt: true, + }, + { no: 3, name: 'metadata', kind: 'message', T: ClientMetadata }, + ]); + static fromBinary(bytes, options) { + return new _OnboardUserRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _OnboardUserRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _OnboardUserRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_OnboardUserRequest, a, b); + } +}; +var OnboardUserResponse = class _OnboardUserResponse extends Message { + /** + * Project that User is onboarded with and should be used by the Client + * (e.g. IDE) + * + * @generated from field: google.internal.cloud.code.v1internal.Project cloudaicompanion_project = 1; + */ + cloudaicompanionProject; + /** + * Status of the OnboardUser call, filled only in case the IDE should + * display informational or warning message. + * + * @generated from field: optional google.internal.cloud.code.v1internal.OnboardUserStatus status = 4; + */ + status; + /** + * The release channel that the current user is opted into. + * + * @generated from field: optional google.internal.cloud.code.v1internal.ReleaseChannel release_channel = 5; + */ + releaseChannel; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.OnboardUserResponse'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'cloudaicompanion_project', kind: 'message', T: Project }, + { no: 4, name: 'status', kind: 'message', T: OnboardUserStatus, opt: true }, + { + no: 5, + name: 'release_channel', + kind: 'message', + T: ReleaseChannel, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _OnboardUserResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _OnboardUserResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _OnboardUserResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_OnboardUserResponse, a, b); + } +}; +var ReleaseChannel = class _ReleaseChannel extends Message { + /** + * The type of the release channel. + * + * @generated from field: google.internal.cloud.code.v1internal.ReleaseChannel.ChannelType type = 1; + */ + type = ReleaseChannel_ChannelType.UNKNOWN; + /** + * The name of the release channel. E.g. "Experimental Channel", "Stable + * Channel". + * + * @generated from field: string name = 2; + */ + name = ''; + /** + * A description message to show on-hover or focus. + * + * @generated from field: string description = 3; + */ + description = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.ReleaseChannel'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(ReleaseChannel_ChannelType), + }, + { + no: 2, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ReleaseChannel().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ReleaseChannel().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ReleaseChannel().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ReleaseChannel, a, b); + } +}; +var ReleaseChannel_ChannelType; +(function (ReleaseChannel_ChannelType2) { + ReleaseChannel_ChannelType2[(ReleaseChannel_ChannelType2['UNKNOWN'] = 0)] = + 'UNKNOWN'; + ReleaseChannel_ChannelType2[(ReleaseChannel_ChannelType2['STABLE'] = 1)] = + 'STABLE'; + ReleaseChannel_ChannelType2[ + (ReleaseChannel_ChannelType2['EXPERIMENTAL'] = 2) + ] = 'EXPERIMENTAL'; +})(ReleaseChannel_ChannelType || (ReleaseChannel_ChannelType = {})); +proto3.util.setEnumType( + ReleaseChannel_ChannelType, + 'google.internal.cloud.code.v1internal.ReleaseChannel.ChannelType', + [ + { no: 0, name: 'UNKNOWN' }, + { no: 1, name: 'STABLE' }, + { no: 2, name: 'EXPERIMENTAL' }, + ], +); +var LoadCodeAssistRequest = class _LoadCodeAssistRequest extends Message { + /** + * project id saved on the client's side previously chosen by the user. + * + * @generated from field: optional string cloudaicompanion_project = 1; + */ + cloudaicompanionProject; + /** + * Optional metadata provided by clients for mendel diversion. + * + * @generated from field: google.internal.cloud.code.v1internal.ClientMetadata metadata = 2; + */ + metadata; + /** + * Mode of the request. This is used to differentiate between different + * requests. For example, health check requests from the IDE + * polling the server for tier status skip some of the checks. + * + * @generated from field: optional google.internal.cloud.code.v1internal.LoadCodeAssistRequest.Mode mode = 3; + */ + mode; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'google.internal.cloud.code.v1internal.LoadCodeAssistRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'cloudaicompanion_project', + kind: 'scalar', + T: 9, + opt: true, + }, + { no: 2, name: 'metadata', kind: 'message', T: ClientMetadata }, + { + no: 3, + name: 'mode', + kind: 'enum', + T: proto3.getEnumType(LoadCodeAssistRequest_Mode), + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _LoadCodeAssistRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LoadCodeAssistRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LoadCodeAssistRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LoadCodeAssistRequest, a, b); + } +}; +var LoadCodeAssistRequest_Mode; +(function (LoadCodeAssistRequest_Mode2) { + LoadCodeAssistRequest_Mode2[ + (LoadCodeAssistRequest_Mode2['MODE_UNSPECIFIED'] = 0) + ] = 'MODE_UNSPECIFIED'; + LoadCodeAssistRequest_Mode2[ + (LoadCodeAssistRequest_Mode2['FULL_ELIGIBILITY_CHECK'] = 1) + ] = 'FULL_ELIGIBILITY_CHECK'; + LoadCodeAssistRequest_Mode2[ + (LoadCodeAssistRequest_Mode2['HEALTH_CHECK'] = 2) + ] = 'HEALTH_CHECK'; +})(LoadCodeAssistRequest_Mode || (LoadCodeAssistRequest_Mode = {})); +proto3.util.setEnumType( + LoadCodeAssistRequest_Mode, + 'google.internal.cloud.code.v1internal.LoadCodeAssistRequest.Mode', + [ + { no: 0, name: 'MODE_UNSPECIFIED' }, + { no: 1, name: 'FULL_ELIGIBILITY_CHECK' }, + { no: 2, name: 'HEALTH_CHECK' }, + ], +); +var IneligibleTier = class _IneligibleTier extends Message { + /** + * mnemonic code representing the reason for in-eligibility. + * + * @generated from field: google.internal.cloud.code.v1internal.IneligibleTier.IneligibleTierReasonCodes reason_code = 1; + */ + reasonCode = IneligibleTier_IneligibleTierReasonCodes.UNKNOWN; + /** + * text message representing the reason for in-eligibility. + * + * @generated from field: string reason_message = 2; + */ + reasonMessage = ''; + /** + * id of the tier. + * + * @generated from field: string tier_id = 3; + */ + tierId = ''; + /** + * human readable name of the tier. + * + * @generated from field: string tier_name = 4; + */ + tierName = ''; + /** + * the validation error message. It includes all descriptions and all urls. + * reason_message uses validation_error_message as a parameter in + * formatting its final message. + * + * @generated from field: string validation_error_message = 5; + */ + validationErrorMessage = ''; + /** + * text to display for the validation url link. + * + * @generated from field: string validation_url_link_text = 6; + */ + validationUrlLinkText = ''; + /** + * url to the validation page. + * + * @generated from field: string validation_url = 7; + */ + validationUrl = ''; + /** + * text to display for the learn more link. + * + * @generated from field: string validation_learn_more_link_text = 8; + */ + validationLearnMoreLinkText = ''; + /** + * url to the learn more page. + * + * @generated from field: string validation_learn_more_url = 9; + */ + validationLearnMoreUrl = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.IneligibleTier'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'reason_code', + kind: 'enum', + T: proto3.getEnumType(IneligibleTier_IneligibleTierReasonCodes), + }, + { + no: 2, + name: 'reason_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'tier_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'tier_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'validation_error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'validation_url_link_text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'validation_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'validation_learn_more_link_text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'validation_learn_more_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _IneligibleTier().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IneligibleTier().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IneligibleTier().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IneligibleTier, a, b); + } +}; +var IneligibleTier_IneligibleTierReasonCodes; +(function (IneligibleTier_IneligibleTierReasonCodes2) { + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['UNKNOWN'] = 0) + ] = 'UNKNOWN'; + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['INELIGIBLE_ACCOUNT'] = 1) + ] = 'INELIGIBLE_ACCOUNT'; + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['UNKNOWN_LOCATION'] = 2) + ] = 'UNKNOWN_LOCATION'; + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['UNSUPPORTED_LOCATION'] = 3) + ] = 'UNSUPPORTED_LOCATION'; + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['RESTRICTED_NETWORK'] = 4) + ] = 'RESTRICTED_NETWORK'; + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['RESTRICTED_AGE'] = 5) + ] = 'RESTRICTED_AGE'; + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['NON_USER_ACCOUNT'] = 6) + ] = 'NON_USER_ACCOUNT'; + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['DASHER_USER'] = 7) + ] = 'DASHER_USER'; + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['BYOID_USER'] = 8) + ] = 'BYOID_USER'; + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['RESTRICTED_DASHER_USER'] = 9) + ] = 'RESTRICTED_DASHER_USER'; + IneligibleTier_IneligibleTierReasonCodes2[ + (IneligibleTier_IneligibleTierReasonCodes2['VALIDATION_REQUIRED'] = 10) + ] = 'VALIDATION_REQUIRED'; +})( + IneligibleTier_IneligibleTierReasonCodes || + (IneligibleTier_IneligibleTierReasonCodes = {}), +); +proto3.util.setEnumType( + IneligibleTier_IneligibleTierReasonCodes, + 'google.internal.cloud.code.v1internal.IneligibleTier.IneligibleTierReasonCodes', + [ + { no: 0, name: 'UNKNOWN' }, + { no: 1, name: 'INELIGIBLE_ACCOUNT' }, + { no: 2, name: 'UNKNOWN_LOCATION' }, + { no: 3, name: 'UNSUPPORTED_LOCATION' }, + { no: 4, name: 'RESTRICTED_NETWORK' }, + { no: 5, name: 'RESTRICTED_AGE' }, + { no: 6, name: 'NON_USER_ACCOUNT' }, + { no: 7, name: 'DASHER_USER' }, + { no: 8, name: 'BYOID_USER' }, + { no: 9, name: 'RESTRICTED_DASHER_USER' }, + { no: 10, name: 'VALIDATION_REQUIRED' }, + ], +); +var ClientMetadata = class _ClientMetadata extends Message { + /** + * Type of the IDE. This is less granular than ide_name. + * + * @generated from field: google.internal.cloud.code.v1internal.ClientMetadata.IdeType ide_type = 1; + */ + ideType = ClientMetadata_IdeType.IDE_UNSPECIFIED; + /** + * IDE version, format is different per IDE. + * + * @generated from field: string ide_version = 2; + */ + ideVersion = ''; + /** + * Plugin version, format is different per plugin. + * + * @generated from field: string plugin_version = 3; + */ + pluginVersion = ''; + /** + * The platform the client is running on. + * + * @generated from field: google.internal.cloud.code.v1internal.ClientMetadata.Platform platform = 4; + */ + platform = ClientMetadata_Platform.PLATFORM_UNSPECIFIED; + /** + * Update channel in use by the client. + * + * @generated from field: string update_channel = 5; + */ + updateChannel = ''; + /** + * Duet project ID or number. + * + * @generated from field: string duet_project = 6; + */ + duetProject = ''; + /** + * Type of the plugin. + * + * @generated from field: google.internal.cloud.code.v1internal.ClientMetadata.PluginType plugin_type = 7; + */ + pluginType = ClientMetadata_PluginType.PLUGIN_UNSPECIFIED; + /** + * IDE name. For example, "PyCharm" or "CLion". More granular than ide_type. + * + * @generated from field: string ide_name = 8; + */ + ideName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.ClientMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'ide_type', + kind: 'enum', + T: proto3.getEnumType(ClientMetadata_IdeType), + }, + { + no: 2, + name: 'ide_version', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'plugin_version', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'platform', + kind: 'enum', + T: proto3.getEnumType(ClientMetadata_Platform), + }, + { + no: 5, + name: 'update_channel', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'duet_project', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'plugin_type', + kind: 'enum', + T: proto3.getEnumType(ClientMetadata_PluginType), + }, + { + no: 8, + name: 'ide_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ClientMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ClientMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ClientMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ClientMetadata, a, b); + } +}; +var ClientMetadata_IdeType; +(function (ClientMetadata_IdeType2) { + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['IDE_UNSPECIFIED'] = 0)] = + 'IDE_UNSPECIFIED'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['VSCODE'] = 1)] = 'VSCODE'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['INTELLIJ'] = 2)] = + 'INTELLIJ'; + ClientMetadata_IdeType2[ + (ClientMetadata_IdeType2['VSCODE_CLOUD_WORKSTATION'] = 3) + ] = 'VSCODE_CLOUD_WORKSTATION'; + ClientMetadata_IdeType2[ + (ClientMetadata_IdeType2['INTELLIJ_CLOUD_WORKSTATION'] = 4) + ] = 'INTELLIJ_CLOUD_WORKSTATION'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['CLOUD_SHELL'] = 5)] = + 'CLOUD_SHELL'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['CIDER'] = 6)] = 'CIDER'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['CLOUD_RUN'] = 7)] = + 'CLOUD_RUN'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['ANDROID_STUDIO'] = 8)] = + 'ANDROID_STUDIO'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['ANTIGRAVITY'] = 9)] = + 'ANTIGRAVITY'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['JETSKI'] = 10)] = 'JETSKI'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['COLAB'] = 11)] = 'COLAB'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['FIREBASE'] = 12)] = + 'FIREBASE'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['CHROME_DEVTOOLS'] = 13)] = + 'CHROME_DEVTOOLS'; + ClientMetadata_IdeType2[(ClientMetadata_IdeType2['GEMINI_CLI'] = 14)] = + 'GEMINI_CLI'; +})(ClientMetadata_IdeType || (ClientMetadata_IdeType = {})); +proto3.util.setEnumType( + ClientMetadata_IdeType, + 'google.internal.cloud.code.v1internal.ClientMetadata.IdeType', + [ + { no: 0, name: 'IDE_UNSPECIFIED' }, + { no: 1, name: 'VSCODE' }, + { no: 2, name: 'INTELLIJ' }, + { no: 3, name: 'VSCODE_CLOUD_WORKSTATION' }, + { no: 4, name: 'INTELLIJ_CLOUD_WORKSTATION' }, + { no: 5, name: 'CLOUD_SHELL' }, + { no: 6, name: 'CIDER' }, + { no: 7, name: 'CLOUD_RUN' }, + { no: 8, name: 'ANDROID_STUDIO' }, + { no: 9, name: 'ANTIGRAVITY' }, + { no: 10, name: 'JETSKI' }, + { no: 11, name: 'COLAB' }, + { no: 12, name: 'FIREBASE' }, + { no: 13, name: 'CHROME_DEVTOOLS' }, + { no: 14, name: 'GEMINI_CLI' }, + ], +); +var ClientMetadata_Platform; +(function (ClientMetadata_Platform2) { + ClientMetadata_Platform2[ + (ClientMetadata_Platform2['PLATFORM_UNSPECIFIED'] = 0) + ] = 'PLATFORM_UNSPECIFIED'; + ClientMetadata_Platform2[(ClientMetadata_Platform2['DARWIN_AMD64'] = 1)] = + 'DARWIN_AMD64'; + ClientMetadata_Platform2[(ClientMetadata_Platform2['DARWIN_ARM64'] = 2)] = + 'DARWIN_ARM64'; + ClientMetadata_Platform2[(ClientMetadata_Platform2['LINUX_AMD64'] = 3)] = + 'LINUX_AMD64'; + ClientMetadata_Platform2[(ClientMetadata_Platform2['LINUX_ARM64'] = 4)] = + 'LINUX_ARM64'; + ClientMetadata_Platform2[(ClientMetadata_Platform2['WINDOWS_AMD64'] = 5)] = + 'WINDOWS_AMD64'; +})(ClientMetadata_Platform || (ClientMetadata_Platform = {})); +proto3.util.setEnumType( + ClientMetadata_Platform, + 'google.internal.cloud.code.v1internal.ClientMetadata.Platform', + [ + { no: 0, name: 'PLATFORM_UNSPECIFIED' }, + { no: 1, name: 'DARWIN_AMD64' }, + { no: 2, name: 'DARWIN_ARM64' }, + { no: 3, name: 'LINUX_AMD64' }, + { no: 4, name: 'LINUX_ARM64' }, + { no: 5, name: 'WINDOWS_AMD64' }, + ], +); +var ClientMetadata_PluginType; +(function (ClientMetadata_PluginType2) { + ClientMetadata_PluginType2[ + (ClientMetadata_PluginType2['PLUGIN_UNSPECIFIED'] = 0) + ] = 'PLUGIN_UNSPECIFIED'; + ClientMetadata_PluginType2[(ClientMetadata_PluginType2['CLOUD_CODE'] = 1)] = + 'CLOUD_CODE'; + ClientMetadata_PluginType2[(ClientMetadata_PluginType2['GEMINI'] = 2)] = + 'GEMINI'; + ClientMetadata_PluginType2[ + (ClientMetadata_PluginType2['AIPLUGIN_INTELLIJ'] = 3) + ] = 'AIPLUGIN_INTELLIJ'; + ClientMetadata_PluginType2[ + (ClientMetadata_PluginType2['AIPLUGIN_STUDIO'] = 4) + ] = 'AIPLUGIN_STUDIO'; + ClientMetadata_PluginType2[(ClientMetadata_PluginType2['PANTHEON'] = 6)] = + 'PANTHEON'; +})(ClientMetadata_PluginType || (ClientMetadata_PluginType = {})); +proto3.util.setEnumType( + ClientMetadata_PluginType, + 'google.internal.cloud.code.v1internal.ClientMetadata.PluginType', + [ + { no: 0, name: 'PLUGIN_UNSPECIFIED' }, + { no: 1, name: 'CLOUD_CODE' }, + { no: 2, name: 'GEMINI' }, + { no: 3, name: 'AIPLUGIN_INTELLIJ' }, + { no: 4, name: 'AIPLUGIN_STUDIO' }, + { no: 6, name: 'PANTHEON' }, + ], +); +var Project = class _Project extends Message { + /** + * The unique, user-assigned ID of the Project. + * Example: `tokyo-rain-123` + * + * @generated from field: string id = 1; + */ + id = ''; + /** + * The optional user-assigned display name of the Project. + * When present it must be between 4 to 30 characters. + * Allowed characters are: lowercase and uppercase letters, numbers, + * hyphen, single-quote, double-quote, space, and exclamation point. + * + * Example: `My Project` + * + * Read-write. + * + * @generated from field: string name = 2; + */ + name = ''; + /** + * GCP project number of the project. + * + * @generated from field: int64 project_number = 3; + */ + projectNumber = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.Project'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'project_number', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _Project().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Project().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Project().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Project, a, b); + } +}; +var OnboardUserStatus = class _OnboardUserStatus extends Message { + /** + * Status code of the message. + * + * @generated from field: google.internal.cloud.code.v1internal.OnboardUserStatus.StatusCode status_code = 1; + */ + statusCode = OnboardUserStatus_StatusCode.DEFAULT; + /** + * The literal message to display on the IDE side. + * + * @generated from field: string display_message = 2; + */ + displayMessage = ''; + /** + * Title of the message to display on the IDE side. + * + * @generated from field: string message_title = 4; + */ + messageTitle = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.OnboardUserStatus'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'status_code', + kind: 'enum', + T: proto3.getEnumType(OnboardUserStatus_StatusCode), + }, + { + no: 2, + name: 'display_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'message_title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _OnboardUserStatus().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _OnboardUserStatus().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _OnboardUserStatus().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_OnboardUserStatus, a, b); + } +}; +var OnboardUserStatus_StatusCode; +(function (OnboardUserStatus_StatusCode2) { + OnboardUserStatus_StatusCode2[ + (OnboardUserStatus_StatusCode2['DEFAULT'] = 0) + ] = 'DEFAULT'; + OnboardUserStatus_StatusCode2[(OnboardUserStatus_StatusCode2['NOTICE'] = 1)] = + 'NOTICE'; + OnboardUserStatus_StatusCode2[ + (OnboardUserStatus_StatusCode2['WARNING'] = 2) + ] = 'WARNING'; +})(OnboardUserStatus_StatusCode || (OnboardUserStatus_StatusCode = {})); +proto3.util.setEnumType( + OnboardUserStatus_StatusCode, + 'google.internal.cloud.code.v1internal.OnboardUserStatus.StatusCode', + [ + { no: 0, name: 'DEFAULT' }, + { no: 1, name: 'NOTICE' }, + { no: 2, name: 'WARNING' }, + ], +); +var LoadCodeAssistResponse = class _LoadCodeAssistResponse extends Message { + /** + * POST PUBLIC PREVIEW: User's current tier; not set if this is not a known + * user + * + * @generated from field: google.internal.cloud.code.v1internal.UserTier current_tier = 1; + */ + currentTier; + /** + * Allowed tiers for this user + * + * @generated from field: repeated google.internal.cloud.code.v1internal.UserTier allowed_tiers = 2; + */ + allowedTiers = []; + /** + * The project that client should pass in calls to Gemini Code Assist. This + * may be overridden by the user. + * This field is non-empty if either: + * 1. The user is already onboarded to free tier - then it contains the free + * tier project ID. + * 2. The LoadCodeAssistRequest contained cloudaicompanion_project and the + * user has all necessary permissions for that project - then it contains + * the project ID from the request. + * + * @generated from field: optional string cloudaicompanion_project = 3; + */ + cloudaicompanionProject; + /** + * List of tiers which user is not eligible for with reason text & reason + * code. + * + * @generated from field: repeated google.internal.cloud.code.v1internal.IneligibleTier ineligible_tiers = 5; + */ + ineligibleTiers = []; + /** + * Indicates whether the cloudaicompanion_project is a GCP project that is + * managed directly by the user, or if it is managed on their behalf, such as + * EasyGCP. IDE extensions may use this field to decide whether to direct + * users to Pantheon or to the GCA standalone web UI. + * + * @generated from field: optional bool gcp_managed = 6; + */ + gcpManaged; + /** + * URI for the user to manage their Gemini Code Assist subscription. + * If this field is not set, the user does not have a subscription or + * client should not show the manage subscription option. + * + * @generated from field: optional string manage_subscription_uri = 7; + */ + manageSubscriptionUri; + /** + * The release channel that the current user is opted into. This value is not + * available if current_tier is not set. + * + * @generated from field: optional google.internal.cloud.code.v1internal.ReleaseChannel release_channel = 8; + */ + releaseChannel; + /** + * URI for the user to upgrade subscription to one of the paid tiers. + * If this field is not set, the user does not have a subscription or + * client should not show the upgrade subscription option. + * + * @generated from field: optional string upgrade_subscription_uri = 9; + */ + upgradeSubscriptionUri; + /** + * Settings fetched from the backend. + * + * @generated from field: optional google.internal.cloud.code.v1internal.GeminiCodeAssistSetting gemini_code_assist_setting = 10; + */ + geminiCodeAssistSetting; + /** + * This is either empty, g1-pro-tier, or g1-ultra-tier. + * + * @generated from field: optional string g1_tier = 11; + */ + g1Tier; + /** + * Exact tier the user is on. This may be more accurate than `current_tier` + * which historically only supported two values: free and standard. + * + * @generated from field: google.internal.cloud.code.v1internal.UserTier paid_tier = 12; + */ + paidTier; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'google.internal.cloud.code.v1internal.LoadCodeAssistResponse'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'current_tier', kind: 'message', T: UserTier }, + { + no: 2, + name: 'allowed_tiers', + kind: 'message', + T: UserTier, + repeated: true, + }, + { + no: 3, + name: 'cloudaicompanion_project', + kind: 'scalar', + T: 9, + opt: true, + }, + { + no: 5, + name: 'ineligible_tiers', + kind: 'message', + T: IneligibleTier, + repeated: true, + }, + { no: 6, name: 'gcp_managed', kind: 'scalar', T: 8, opt: true }, + { no: 7, name: 'manage_subscription_uri', kind: 'scalar', T: 9, opt: true }, + { + no: 8, + name: 'release_channel', + kind: 'message', + T: ReleaseChannel, + opt: true, + }, + { + no: 9, + name: 'upgrade_subscription_uri', + kind: 'scalar', + T: 9, + opt: true, + }, + { + no: 10, + name: 'gemini_code_assist_setting', + kind: 'message', + T: GeminiCodeAssistSetting, + opt: true, + }, + { no: 11, name: 'g1_tier', kind: 'scalar', T: 9, opt: true }, + { no: 12, name: 'paid_tier', kind: 'message', T: UserTier }, + ]); + static fromBinary(bytes, options) { + return new _LoadCodeAssistResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LoadCodeAssistResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LoadCodeAssistResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LoadCodeAssistResponse, a, b); + } +}; +var UserTier = class _UserTier extends Message { + /** + * ID of this tier + * + * @generated from field: string id = 1; + */ + id = ''; + /** + * Short name for this tier; shown in the client UI + * + * @generated from field: string name = 2; + */ + name = ''; + /** + * Brief description of this tier; shown in the client UI + * + * @generated from field: string description = 3; + */ + description = ''; + /** + * Indicates for this tier type if a Gemini service-enabled project needs to + * be managed by the user. + * If set to false, the backend will handle the project creation, and details + * about the project need not be surfaced to the end user. + * If set to true, the IDE client needs users to select a project and provide + * it to the backend in their requests to the OnboardUser rpc. + * + * @generated from field: bool user_defined_cloudaicompanion_project = 4; + */ + userDefinedCloudaicompanionProject = false; + /** + * The privacy notice to be shown to the User + * + * @generated from field: google.internal.cloud.code.v1internal.UserTier.PrivacyNotice privacy_notice = 5; + */ + privacyNotice; + /** + * Indicates if this tier should be treated as default by the IDE + * Only 1 tier can be default. If auto-onboarding, this tier is the one to + * auto-onboard to. If User is presented with option to choose tiers, the one + * with the default flag is the preselected one. + * + * @generated from field: bool is_default = 6; + */ + isDefault = false; + /** + * URI for the user to upgrade subscription to one of the paid tiers. + * If this field is not set, the client should not show the upgrade + * subscription option. + * + * @generated from field: optional string upgrade_subscription_uri = 7; + */ + upgradeSubscriptionUri; + /** + * Text to display for the upgrade subscription notification. If this field is + * not set, the client should not show the upgrade subscription option. + * + * @generated from field: optional string upgrade_subscription_text = 8; + */ + upgradeSubscriptionText; + /** + * Text to display for the upgrade button. If this field is not set, the + * client will show the text "Upgrade". + * + * @generated from field: optional string upgrade_button_text = 11; + */ + upgradeButtonText; + /** + * Text to display client-side UI tag. For Antigravity, this is used + * to display "Preview" for Workspace users. + * + * @generated from field: optional string client_experience_tag = 12; + */ + clientExperienceTag; + /** + * The type of upgrade offered to the user. This is used to expand the events + * with the type of upgrade. + * + * @generated from field: optional google.internal.cloud.code.v1internal.UserTier.UpgradeType upgrade_subscription_type = 9; + */ + upgradeSubscriptionType; + /** + * Indicates if this tier uses the Google Cloud Platform Terms of Service. + * + * @generated from field: bool uses_gcp_tos = 13; + */ + usesGcpTos = false; + /** + * The credits available to the user for this tier. + * This is used to display the number of credits remaining to the user in the + * client UI. + * + * @generated from field: repeated google.internal.cloud.code.v1internal.Credits available_credits = 14; + */ + availableCredits = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.UserTier'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'user_defined_cloudaicompanion_project', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'privacy_notice', + kind: 'message', + T: UserTier_PrivacyNotice, + }, + { + no: 6, + name: 'is_default', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'upgrade_subscription_uri', + kind: 'scalar', + T: 9, + opt: true, + }, + { + no: 8, + name: 'upgrade_subscription_text', + kind: 'scalar', + T: 9, + opt: true, + }, + { no: 11, name: 'upgrade_button_text', kind: 'scalar', T: 9, opt: true }, + { no: 12, name: 'client_experience_tag', kind: 'scalar', T: 9, opt: true }, + { + no: 9, + name: 'upgrade_subscription_type', + kind: 'enum', + T: proto3.getEnumType(UserTier_UpgradeType), + opt: true, + }, + { + no: 13, + name: 'uses_gcp_tos', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 14, + name: 'available_credits', + kind: 'message', + T: Credits, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _UserTier().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserTier().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserTier().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserTier, a, b); + } +}; +var UserTier_UpgradeType; +(function (UserTier_UpgradeType2) { + UserTier_UpgradeType2[ + (UserTier_UpgradeType2['UPGRADE_TYPE_UNSPECIFIED'] = 0) + ] = 'UPGRADE_TYPE_UNSPECIFIED'; + UserTier_UpgradeType2[(UserTier_UpgradeType2['GDP'] = 1)] = 'GDP'; + UserTier_UpgradeType2[(UserTier_UpgradeType2['GOOGLE_ONE'] = 2)] = + 'GOOGLE_ONE'; + UserTier_UpgradeType2[(UserTier_UpgradeType2['GDP_HELIUM'] = 3)] = + 'GDP_HELIUM'; + UserTier_UpgradeType2[(UserTier_UpgradeType2['GOOGLE_ONE_HELIUM'] = 4)] = + 'GOOGLE_ONE_HELIUM'; +})(UserTier_UpgradeType || (UserTier_UpgradeType = {})); +proto3.util.setEnumType( + UserTier_UpgradeType, + 'google.internal.cloud.code.v1internal.UserTier.UpgradeType', + [ + { no: 0, name: 'UPGRADE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'GDP' }, + { no: 2, name: 'GOOGLE_ONE' }, + { no: 3, name: 'GDP_HELIUM' }, + { no: 4, name: 'GOOGLE_ONE_HELIUM' }, + ], +); +var UserTier_PrivacyNotice = class _UserTier_PrivacyNotice extends Message { + /** + * If true, the privacy notice should be shown to the user. + * + * @generated from field: bool show_notice = 1; + */ + showNotice = false; + /** + * The literal message to display on the IDE side. This is a markdown + * string. If `show_notice` is true, this field must be set. + * + * @generated from field: optional string notice_text = 2; + */ + noticeText; + /** + * If true, the privacy notice is for a minor user. + * + * @generated from field: bool minor_notice = 4; + */ + minorNotice = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'google.internal.cloud.code.v1internal.UserTier.PrivacyNotice'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'show_notice', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 2, name: 'notice_text', kind: 'scalar', T: 9, opt: true }, + { + no: 4, + name: 'minor_notice', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _UserTier_PrivacyNotice().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserTier_PrivacyNotice().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserTier_PrivacyNotice().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserTier_PrivacyNotice, a, b); + } +}; +var GeminiCodeAssistSetting = class _GeminiCodeAssistSetting extends Message { + /** + * Whether telemetry should be disabled. + * + * @generated from field: bool disable_telemetry = 1; + */ + disableTelemetry = false; + /** + * Whether feedback should be disabled. + * + * @generated from field: bool disable_feedback = 2; + */ + disableFeedback = false; + /** + * The policy used to handle recitation. + * + * @generated from field: google.internal.cloud.code.v1internal.RecitationPolicy recitation_policy = 3; + */ + recitationPolicy; + /** + * The grounding type used for the Gemini Code Assist. + * + * @generated from field: google.internal.cloud.code.v1internal.GeminiCodeAssistSetting.GroundingType grounding_type = 4; + */ + groundingType = + GeminiCodeAssistSetting_GroundingType.GROUNDING_TYPE_UNSPECIFIED; + /** + * Whether secure mode is enabled. + * If true, certain features (e.g. turbo/YOLO mode, browser features) will + * be disabled. + * + * @generated from field: bool secure_mode_enabled = 5; + */ + secureModeEnabled = false; + /** + * Controls MCP enablement and MCP server configurations. + * + * @generated from field: google.internal.cloud.code.v1internal.McpSetting mcp_setting = 6; + */ + mcpSetting; + /** + * Controls the turbo mode enablement and its behavior. + * + * @generated from field: google.internal.cloud.code.v1internal.TurboModeSetting turbo_mode_setting = 7; + */ + turboModeSetting; + /** + * Controls the browser feature enablement and its behavior. + * + * @generated from field: google.internal.cloud.code.v1internal.BrowserSetting browser_setting = 8; + */ + browserSetting; + /** + * Controls enablement and behavior of preview features. + * + * @generated from field: google.internal.cloud.code.v1internal.PreviewFeatureSetting preview_feature_setting = 9; + */ + previewFeatureSetting; + /** + * Controls the agentic workflows features and their behavior. + * + * @generated from field: google.internal.cloud.code.v1internal.AgentSetting agent_setting = 10; + */ + agentSetting; + /** + * Controls the CLI feature enablement and their behavior. + * + * @generated from field: google.internal.cloud.code.v1internal.CliFeatureSetting cli_feature_setting = 11; + */ + cliFeatureSetting; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'google.internal.cloud.code.v1internal.GeminiCodeAssistSetting'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'disable_telemetry', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'disable_feedback', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 3, name: 'recitation_policy', kind: 'message', T: RecitationPolicy }, + { + no: 4, + name: 'grounding_type', + kind: 'enum', + T: proto3.getEnumType(GeminiCodeAssistSetting_GroundingType), + }, + { + no: 5, + name: 'secure_mode_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 6, name: 'mcp_setting', kind: 'message', T: McpSetting }, + { no: 7, name: 'turbo_mode_setting', kind: 'message', T: TurboModeSetting }, + { no: 8, name: 'browser_setting', kind: 'message', T: BrowserSetting }, + { + no: 9, + name: 'preview_feature_setting', + kind: 'message', + T: PreviewFeatureSetting, + }, + { no: 10, name: 'agent_setting', kind: 'message', T: AgentSetting }, + { + no: 11, + name: 'cli_feature_setting', + kind: 'message', + T: CliFeatureSetting, + }, + ]); + static fromBinary(bytes, options) { + return new _GeminiCodeAssistSetting().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GeminiCodeAssistSetting().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GeminiCodeAssistSetting().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GeminiCodeAssistSetting, a, b); + } +}; +var GeminiCodeAssistSetting_GroundingType; +(function (GeminiCodeAssistSetting_GroundingType2) { + GeminiCodeAssistSetting_GroundingType2[ + (GeminiCodeAssistSetting_GroundingType2['GROUNDING_TYPE_UNSPECIFIED'] = 0) + ] = 'GROUNDING_TYPE_UNSPECIFIED'; + GeminiCodeAssistSetting_GroundingType2[ + (GeminiCodeAssistSetting_GroundingType2['GROUNDING_WITH_GOOGLE_SEARCH'] = 1) + ] = 'GROUNDING_WITH_GOOGLE_SEARCH'; + GeminiCodeAssistSetting_GroundingType2[ + (GeminiCodeAssistSetting_GroundingType2['WEB_GROUNDING_FOR_ENTERPRISE'] = 2) + ] = 'WEB_GROUNDING_FOR_ENTERPRISE'; +})( + GeminiCodeAssistSetting_GroundingType || + (GeminiCodeAssistSetting_GroundingType = {}), +); +proto3.util.setEnumType( + GeminiCodeAssistSetting_GroundingType, + 'google.internal.cloud.code.v1internal.GeminiCodeAssistSetting.GroundingType', + [ + { no: 0, name: 'GROUNDING_TYPE_UNSPECIFIED' }, + { no: 1, name: 'GROUNDING_WITH_GOOGLE_SEARCH' }, + { no: 2, name: 'WEB_GROUNDING_FOR_ENTERPRISE' }, + ], +); +var RecitationPolicy = class _RecitationPolicy extends Message { + /** + * Whether citations should be disabled. + * + * @generated from field: bool disable_citations = 1; + */ + disableCitations = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.RecitationPolicy'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'disable_citations', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _RecitationPolicy().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RecitationPolicy().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RecitationPolicy().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RecitationPolicy, a, b); + } +}; +var McpSetting = class _McpSetting extends Message { + /** + * Whether MCP servers are enabled. + * + * @generated from field: bool mcp_enabled = 1; + */ + mcpEnabled = false; + /** + * MCP config in JSON format. + * + * @generated from field: string override_mcp_config_json = 2; + */ + overrideMcpConfigJson = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.McpSetting'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'mcp_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'override_mcp_config_json', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _McpSetting().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpSetting().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpSetting().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpSetting, a, b); + } +}; +var TurboModeSetting = class _TurboModeSetting extends Message { + /** + * Whether terminal auto execution is enabled. + * + * @generated from field: bool terminal_auto_execution_enabled = 1; + */ + terminalAutoExecutionEnabled = false; + /** + * Whether browser JS execution is enabled. + * + * @generated from field: bool browser_js_execution_enabled = 2; + */ + browserJsExecutionEnabled = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.TurboModeSetting'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'terminal_auto_execution_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'browser_js_execution_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _TurboModeSetting().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TurboModeSetting().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TurboModeSetting().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TurboModeSetting, a, b); + } +}; +var BrowserSetting = class _BrowserSetting extends Message { + /** + * Whether browser is enabled. + * + * @generated from field: bool browser_enabled = 1; + */ + browserEnabled = false; + /** + * The list of websites that are allowed to be accessed. + * + * @generated from field: repeated string allowed_websites = 2; + */ + allowedWebsites = []; + /** + * The list of websites that are denied to be accessed. + * + * @generated from field: repeated string denied_websites = 3; + */ + deniedWebsites = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.BrowserSetting'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'browser_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 2, name: 'allowed_websites', kind: 'scalar', T: 9, repeated: true }, + { no: 3, name: 'denied_websites', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _BrowserSetting().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserSetting().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserSetting().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserSetting, a, b); + } +}; +var PreviewFeatureSetting = class _PreviewFeatureSetting extends Message { + /** + * Whether preview models are enabled. + * + * @generated from field: bool preview_models_enabled = 1; + */ + previewModelsEnabled = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'google.internal.cloud.code.v1internal.PreviewFeatureSetting'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'preview_models_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _PreviewFeatureSetting().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PreviewFeatureSetting().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PreviewFeatureSetting().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PreviewFeatureSetting, a, b); + } +}; +var AgentSetting = class _AgentSetting extends Message { + /** + * The list of models that are allowed to be used by the agentic workflows in + * Antigravity. + * + * @generated from field: repeated string agy_allowed_models = 1; + */ + agyAllowedModels = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.AgentSetting'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'agy_allowed_models', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _AgentSetting().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AgentSetting().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AgentSetting().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AgentSetting, a, b); + } +}; +var CliFeatureSetting = class _CliFeatureSetting extends Message { + /** + * CLI extensions settings. + * + * @generated from field: google.internal.cloud.code.v1internal.CliFeatureSetting.ExtensionsSetting extensions_setting = 1; + */ + extensionsSetting; + /** + * Whether unmanaged capabilities are enabled. This is used to enable / + * disable features that don't have granular admin controls yet. + * + * @generated from field: bool unmanaged_capabilities_enabled = 2; + */ + unmanagedCapabilitiesEnabled = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'google.internal.cloud.code.v1internal.CliFeatureSetting'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'extensions_setting', + kind: 'message', + T: CliFeatureSetting_ExtensionsSetting, + }, + { + no: 2, + name: 'unmanaged_capabilities_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CliFeatureSetting().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CliFeatureSetting().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CliFeatureSetting().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CliFeatureSetting, a, b); + } +}; +var CliFeatureSetting_ExtensionsSetting = class _CliFeatureSetting_ExtensionsSetting extends Message { + /** + * Whether CLI extensions are enabled. + * + * @generated from field: bool extensions_enabled = 1; + */ + extensionsEnabled = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'google.internal.cloud.code.v1internal.CliFeatureSetting.ExtensionsSetting'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'extensions_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CliFeatureSetting_ExtensionsSetting().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CliFeatureSetting_ExtensionsSetting().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CliFeatureSetting_ExtensionsSetting().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CliFeatureSetting_ExtensionsSetting, a, b); + } +}; +var FetchAdminControlsRequest = class _FetchAdminControlsRequest extends Message { + /** + * Project id saved on the client's side previously chosen by the user. + * + * @generated from field: string project = 1; + */ + project = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'google.internal.cloud.code.v1internal.FetchAdminControlsRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'project', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _FetchAdminControlsRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FetchAdminControlsRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FetchAdminControlsRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FetchAdminControlsRequest, a, b); + } +}; +var FetchAdminControlsResponse = class _FetchAdminControlsResponse extends Message { + /** + * Effective settings values for the project. + * Whether telemetry should be disabled. + * + * @generated from field: bool disable_telemetry = 1; + */ + disableTelemetry = false; + /** + * Whether feedback should be disabled. + * + * @generated from field: bool disable_feedback = 2; + */ + disableFeedback = false; + /** + * The policy used to handle recitation. + * + * @generated from field: google.internal.cloud.code.v1internal.RecitationPolicy recitation_policy = 3; + */ + recitationPolicy; + /** + * The grounding type used for the Gemini Code Assist. + * + * @generated from field: google.internal.cloud.code.v1internal.FetchAdminControlsResponse.GroundingType grounding_type = 4; + */ + groundingType = + FetchAdminControlsResponse_GroundingType.GROUNDING_TYPE_UNSPECIFIED; + /** + * Whether secure mode is enabled. + * If true, certain features (e.g. turbo/YOLO mode, browser features) will + * be disabled. + * + * @generated from field: bool secure_mode_enabled = 5; + */ + secureModeEnabled = false; + /** + * Controls MCP enablement and MCP server configurations. + * + * @generated from field: google.internal.cloud.code.v1internal.McpSetting mcp_setting = 6; + */ + mcpSetting; + /** + * Controls the turbo mode enablement and its behavior. + * + * @generated from field: google.internal.cloud.code.v1internal.TurboModeSetting turbo_mode_setting = 7; + */ + turboModeSetting; + /** + * Controls the browser feature enablement and its behavior. + * + * @generated from field: google.internal.cloud.code.v1internal.BrowserSetting browser_setting = 8; + */ + browserSetting; + /** + * Controls enablement and behavior of preview features. + * + * @generated from field: google.internal.cloud.code.v1internal.PreviewFeatureSetting preview_feature_setting = 9; + */ + previewFeatureSetting; + /** + * Controls the agentic workflows features and their behavior. + * + * @generated from field: google.internal.cloud.code.v1internal.AgentSetting agent_setting = 10; + */ + agentSetting; + /** + * Controls the CLI feature enablement and their behavior. + * + * @generated from field: google.internal.cloud.code.v1internal.CliFeatureSetting cli_feature_setting = 11; + */ + cliFeatureSetting; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'google.internal.cloud.code.v1internal.FetchAdminControlsResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'disable_telemetry', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'disable_feedback', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 3, name: 'recitation_policy', kind: 'message', T: RecitationPolicy }, + { + no: 4, + name: 'grounding_type', + kind: 'enum', + T: proto3.getEnumType(FetchAdminControlsResponse_GroundingType), + }, + { + no: 5, + name: 'secure_mode_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 6, name: 'mcp_setting', kind: 'message', T: McpSetting }, + { no: 7, name: 'turbo_mode_setting', kind: 'message', T: TurboModeSetting }, + { no: 8, name: 'browser_setting', kind: 'message', T: BrowserSetting }, + { + no: 9, + name: 'preview_feature_setting', + kind: 'message', + T: PreviewFeatureSetting, + }, + { no: 10, name: 'agent_setting', kind: 'message', T: AgentSetting }, + { + no: 11, + name: 'cli_feature_setting', + kind: 'message', + T: CliFeatureSetting, + }, + ]); + static fromBinary(bytes, options) { + return new _FetchAdminControlsResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FetchAdminControlsResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FetchAdminControlsResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_FetchAdminControlsResponse, a, b); + } +}; +var FetchAdminControlsResponse_GroundingType; +(function (FetchAdminControlsResponse_GroundingType2) { + FetchAdminControlsResponse_GroundingType2[ + (FetchAdminControlsResponse_GroundingType2['GROUNDING_TYPE_UNSPECIFIED'] = + 0) + ] = 'GROUNDING_TYPE_UNSPECIFIED'; + FetchAdminControlsResponse_GroundingType2[ + (FetchAdminControlsResponse_GroundingType2['GROUNDING_WITH_GOOGLE_SEARCH'] = + 1) + ] = 'GROUNDING_WITH_GOOGLE_SEARCH'; + FetchAdminControlsResponse_GroundingType2[ + (FetchAdminControlsResponse_GroundingType2['WEB_GROUNDING_FOR_ENTERPRISE'] = + 2) + ] = 'WEB_GROUNDING_FOR_ENTERPRISE'; +})( + FetchAdminControlsResponse_GroundingType || + (FetchAdminControlsResponse_GroundingType = {}), +); +proto3.util.setEnumType( + FetchAdminControlsResponse_GroundingType, + 'google.internal.cloud.code.v1internal.FetchAdminControlsResponse.GroundingType', + [ + { no: 0, name: 'GROUNDING_TYPE_UNSPECIFIED' }, + { no: 1, name: 'GROUNDING_WITH_GOOGLE_SEARCH' }, + { no: 2, name: 'WEB_GROUNDING_FOR_ENTERPRISE' }, + ], +); + +// exa/proto_ts/dist/exa/codeium_common_pb/codeium_common_pb.js +var CommandRequestSource; +(function (CommandRequestSource2) { + CommandRequestSource2[(CommandRequestSource2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CommandRequestSource2[(CommandRequestSource2['DEFAULT'] = 1)] = 'DEFAULT'; + CommandRequestSource2[(CommandRequestSource2['PLAN'] = 7)] = 'PLAN'; + CommandRequestSource2[(CommandRequestSource2['FAST_APPLY'] = 12)] = + 'FAST_APPLY'; + CommandRequestSource2[(CommandRequestSource2['TERMINAL'] = 13)] = 'TERMINAL'; + CommandRequestSource2[(CommandRequestSource2['SUPERCOMPLETE'] = 10)] = + 'SUPERCOMPLETE'; + CommandRequestSource2[(CommandRequestSource2['TAB_JUMP'] = 14)] = 'TAB_JUMP'; + CommandRequestSource2[(CommandRequestSource2['CASCADE_CHAT'] = 16)] = + 'CASCADE_CHAT'; +})(CommandRequestSource || (CommandRequestSource = {})); +proto3.util.setEnumType( + CommandRequestSource, + 'exa.codeium_common_pb.CommandRequestSource', + [ + { no: 0, name: 'COMMAND_REQUEST_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'COMMAND_REQUEST_SOURCE_DEFAULT' }, + { no: 7, name: 'COMMAND_REQUEST_SOURCE_PLAN' }, + { no: 12, name: 'COMMAND_REQUEST_SOURCE_FAST_APPLY' }, + { no: 13, name: 'COMMAND_REQUEST_SOURCE_TERMINAL' }, + { no: 10, name: 'COMMAND_REQUEST_SOURCE_SUPERCOMPLETE' }, + { no: 14, name: 'COMMAND_REQUEST_SOURCE_TAB_JUMP' }, + { no: 16, name: 'COMMAND_REQUEST_SOURCE_CASCADE_CHAT' }, + ], +); +var ProviderSource; +(function (ProviderSource2) { + ProviderSource2[(ProviderSource2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ProviderSource2[(ProviderSource2['AUTOCOMPLETE'] = 1)] = 'AUTOCOMPLETE'; + ProviderSource2[(ProviderSource2['COMMAND_GENERATE'] = 4)] = + 'COMMAND_GENERATE'; + ProviderSource2[(ProviderSource2['COMMAND_EDIT'] = 5)] = 'COMMAND_EDIT'; + ProviderSource2[(ProviderSource2['SUPERCOMPLETE'] = 6)] = 'SUPERCOMPLETE'; + ProviderSource2[(ProviderSource2['COMMAND_PLAN'] = 7)] = 'COMMAND_PLAN'; + ProviderSource2[(ProviderSource2['FAST_APPLY'] = 9)] = 'FAST_APPLY'; + ProviderSource2[(ProviderSource2['COMMAND_TERMINAL'] = 10)] = + 'COMMAND_TERMINAL'; + ProviderSource2[(ProviderSource2['TAB_JUMP'] = 11)] = 'TAB_JUMP'; + ProviderSource2[(ProviderSource2['CASCADE'] = 12)] = 'CASCADE'; +})(ProviderSource || (ProviderSource = {})); +proto3.util.setEnumType( + ProviderSource, + 'exa.codeium_common_pb.ProviderSource', + [ + { no: 0, name: 'PROVIDER_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'PROVIDER_SOURCE_AUTOCOMPLETE' }, + { no: 4, name: 'PROVIDER_SOURCE_COMMAND_GENERATE' }, + { no: 5, name: 'PROVIDER_SOURCE_COMMAND_EDIT' }, + { no: 6, name: 'PROVIDER_SOURCE_SUPERCOMPLETE' }, + { no: 7, name: 'PROVIDER_SOURCE_COMMAND_PLAN' }, + { no: 9, name: 'PROVIDER_SOURCE_FAST_APPLY' }, + { no: 10, name: 'PROVIDER_SOURCE_COMMAND_TERMINAL' }, + { no: 11, name: 'PROVIDER_SOURCE_TAB_JUMP' }, + { no: 12, name: 'PROVIDER_SOURCE_CASCADE' }, + ], +); +var PromptElementKind; +(function (PromptElementKind2) { + PromptElementKind2[(PromptElementKind2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + PromptElementKind2[(PromptElementKind2['FILE_MARKER'] = 2)] = 'FILE_MARKER'; + PromptElementKind2[(PromptElementKind2['OTHER_DOCUMENT'] = 4)] = + 'OTHER_DOCUMENT'; + PromptElementKind2[(PromptElementKind2['BEFORE_CURSOR'] = 5)] = + 'BEFORE_CURSOR'; + PromptElementKind2[(PromptElementKind2['AFTER_CURSOR'] = 7)] = 'AFTER_CURSOR'; + PromptElementKind2[(PromptElementKind2['FIM'] = 8)] = 'FIM'; + PromptElementKind2[(PromptElementKind2['SOT'] = 9)] = 'SOT'; + PromptElementKind2[(PromptElementKind2['EOT'] = 10)] = 'EOT'; + PromptElementKind2[(PromptElementKind2['CODE_CONTEXT_ITEM'] = 13)] = + 'CODE_CONTEXT_ITEM'; + PromptElementKind2[(PromptElementKind2['INSTRUCTION'] = 14)] = 'INSTRUCTION'; + PromptElementKind2[(PromptElementKind2['SELECTION'] = 15)] = 'SELECTION'; + PromptElementKind2[(PromptElementKind2['TRAJECTORY_STEP'] = 16)] = + 'TRAJECTORY_STEP'; + PromptElementKind2[(PromptElementKind2['ACTIVE_DOCUMENT'] = 17)] = + 'ACTIVE_DOCUMENT'; + PromptElementKind2[(PromptElementKind2['CACHED_MESSAGE'] = 18)] = + 'CACHED_MESSAGE'; +})(PromptElementKind || (PromptElementKind = {})); +proto3.util.setEnumType( + PromptElementKind, + 'exa.codeium_common_pb.PromptElementKind', + [ + { no: 0, name: 'PROMPT_ELEMENT_KIND_UNSPECIFIED' }, + { no: 2, name: 'PROMPT_ELEMENT_KIND_FILE_MARKER' }, + { no: 4, name: 'PROMPT_ELEMENT_KIND_OTHER_DOCUMENT' }, + { no: 5, name: 'PROMPT_ELEMENT_KIND_BEFORE_CURSOR' }, + { no: 7, name: 'PROMPT_ELEMENT_KIND_AFTER_CURSOR' }, + { no: 8, name: 'PROMPT_ELEMENT_KIND_FIM' }, + { no: 9, name: 'PROMPT_ELEMENT_KIND_SOT' }, + { no: 10, name: 'PROMPT_ELEMENT_KIND_EOT' }, + { no: 13, name: 'PROMPT_ELEMENT_KIND_CODE_CONTEXT_ITEM' }, + { no: 14, name: 'PROMPT_ELEMENT_KIND_INSTRUCTION' }, + { no: 15, name: 'PROMPT_ELEMENT_KIND_SELECTION' }, + { no: 16, name: 'PROMPT_ELEMENT_KIND_TRAJECTORY_STEP' }, + { no: 17, name: 'PROMPT_ELEMENT_KIND_ACTIVE_DOCUMENT' }, + { no: 18, name: 'PROMPT_ELEMENT_KIND_CACHED_MESSAGE' }, + ], +); +var PromptAnnotationKind; +(function (PromptAnnotationKind2) { + PromptAnnotationKind2[(PromptAnnotationKind2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + PromptAnnotationKind2[(PromptAnnotationKind2['COPY'] = 1)] = 'COPY'; + PromptAnnotationKind2[(PromptAnnotationKind2['PROMPT_CACHE'] = 2)] = + 'PROMPT_CACHE'; +})(PromptAnnotationKind || (PromptAnnotationKind = {})); +proto3.util.setEnumType( + PromptAnnotationKind, + 'exa.codeium_common_pb.PromptAnnotationKind', + [ + { no: 0, name: 'PROMPT_ANNOTATION_KIND_UNSPECIFIED' }, + { no: 1, name: 'PROMPT_ANNOTATION_KIND_COPY' }, + { no: 2, name: 'PROMPT_ANNOTATION_KIND_PROMPT_CACHE' }, + ], +); +var ExperimentKey; +(function (ExperimentKey2) { + ExperimentKey2[(ExperimentKey2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ExperimentKey2[(ExperimentKey2['USE_INTERNAL_CHAT_MODEL'] = 36)] = + 'USE_INTERNAL_CHAT_MODEL'; + ExperimentKey2[(ExperimentKey2['RECORD_FILES'] = 47)] = 'RECORD_FILES'; + ExperimentKey2[(ExperimentKey2['NO_SAMPLER_EARLY_STOP'] = 48)] = + 'NO_SAMPLER_EARLY_STOP'; + ExperimentKey2[(ExperimentKey2['CM_MEMORY_TELEMETRY'] = 53)] = + 'CM_MEMORY_TELEMETRY'; + ExperimentKey2[(ExperimentKey2['LANGUAGE_SERVER_VERSION'] = 55)] = + 'LANGUAGE_SERVER_VERSION'; + ExperimentKey2[(ExperimentKey2['LANGUAGE_SERVER_AUTO_RELOAD'] = 56)] = + 'LANGUAGE_SERVER_AUTO_RELOAD'; + ExperimentKey2[(ExperimentKey2['ONLY_MULTILINE'] = 60)] = 'ONLY_MULTILINE'; + ExperimentKey2[(ExperimentKey2['USE_ATTRIBUTION_FOR_INDIVIDUAL_TIER'] = 68)] = + 'USE_ATTRIBUTION_FOR_INDIVIDUAL_TIER'; + ExperimentKey2[(ExperimentKey2['CHAT_MODEL_CONFIG'] = 78)] = + 'CHAT_MODEL_CONFIG'; + ExperimentKey2[(ExperimentKey2['COMMAND_MODEL_CONFIG'] = 79)] = + 'COMMAND_MODEL_CONFIG'; + ExperimentKey2[(ExperimentKey2['MIN_IDE_VERSION'] = 81)] = 'MIN_IDE_VERSION'; + ExperimentKey2[(ExperimentKey2['API_SERVER_VERBOSE_ERRORS'] = 84)] = + 'API_SERVER_VERBOSE_ERRORS'; + ExperimentKey2[(ExperimentKey2['DEFAULT_ENABLE_SEARCH'] = 86)] = + 'DEFAULT_ENABLE_SEARCH'; + ExperimentKey2[(ExperimentKey2['COLLECT_ONBOARDING_EVENTS'] = 87)] = + 'COLLECT_ONBOARDING_EVENTS'; + ExperimentKey2[(ExperimentKey2['COLLECT_EXAMPLE_COMPLETIONS'] = 88)] = + 'COLLECT_EXAMPLE_COMPLETIONS'; + ExperimentKey2[(ExperimentKey2['USE_MULTILINE_MODEL'] = 89)] = + 'USE_MULTILINE_MODEL'; + ExperimentKey2[(ExperimentKey2['ATTRIBUTION_KILL_SWITCH'] = 92)] = + 'ATTRIBUTION_KILL_SWITCH'; + ExperimentKey2[(ExperimentKey2['FAST_MULTILINE'] = 94)] = 'FAST_MULTILINE'; + ExperimentKey2[(ExperimentKey2['SINGLE_COMPLETION'] = 95)] = + 'SINGLE_COMPLETION'; + ExperimentKey2[(ExperimentKey2['STOP_FIRST_NON_WHITESPACE_LINE'] = 96)] = + 'STOP_FIRST_NON_WHITESPACE_LINE'; + ExperimentKey2[(ExperimentKey2['CORTEX_CONFIG'] = 102)] = 'CORTEX_CONFIG'; + ExperimentKey2[(ExperimentKey2['MODEL_CHAT_11121_VARIANTS'] = 103)] = + 'MODEL_CHAT_11121_VARIANTS'; + ExperimentKey2[(ExperimentKey2['INCLUDE_PROMPT_COMPONENTS'] = 105)] = + 'INCLUDE_PROMPT_COMPONENTS'; + ExperimentKey2[(ExperimentKey2['PERSIST_CODE_TRACKER'] = 108)] = + 'PERSIST_CODE_TRACKER'; + ExperimentKey2[(ExperimentKey2['API_SERVER_LIVENESS_PROBE'] = 112)] = + 'API_SERVER_LIVENESS_PROBE'; + ExperimentKey2[(ExperimentKey2['CHAT_COMPLETION_TOKENS_SOFT_LIMIT'] = 114)] = + 'CHAT_COMPLETION_TOKENS_SOFT_LIMIT'; + ExperimentKey2[(ExperimentKey2['CHAT_TOKENS_SOFT_LIMIT'] = 115)] = + 'CHAT_TOKENS_SOFT_LIMIT'; + ExperimentKey2[(ExperimentKey2['DISABLE_COMPLETIONS_CACHE'] = 118)] = + 'DISABLE_COMPLETIONS_CACHE'; + ExperimentKey2[(ExperimentKey2['LLAMA3_405B_KILL_SWITCH'] = 119)] = + 'LLAMA3_405B_KILL_SWITCH'; + ExperimentKey2[(ExperimentKey2['USE_COMMAND_DOCSTRING_GENERATION'] = 121)] = + 'USE_COMMAND_DOCSTRING_GENERATION'; + ExperimentKey2[(ExperimentKey2['SENTRY'] = 136)] = 'SENTRY'; + ExperimentKey2[(ExperimentKey2['FAST_SINGLELINE'] = 144)] = 'FAST_SINGLELINE'; + ExperimentKey2[(ExperimentKey2['R2_LANGUAGE_SERVER_DOWNLOAD'] = 147)] = + 'R2_LANGUAGE_SERVER_DOWNLOAD'; + ExperimentKey2[(ExperimentKey2['SPLIT_MODEL'] = 152)] = 'SPLIT_MODEL'; + ExperimentKey2[(ExperimentKey2['ANTIGRAVITY_SENTRY_SAMPLE_RATE'] = 198)] = + 'ANTIGRAVITY_SENTRY_SAMPLE_RATE'; + ExperimentKey2[(ExperimentKey2['API_SERVER_CUTOFF'] = 158)] = + 'API_SERVER_CUTOFF'; + ExperimentKey2[(ExperimentKey2['FAST_SPEED_KILL_SWITCH'] = 159)] = + 'FAST_SPEED_KILL_SWITCH'; + ExperimentKey2[(ExperimentKey2['PREDICTIVE_MULTILINE'] = 160)] = + 'PREDICTIVE_MULTILINE'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_FILTER_REVERT'] = 125)] = + 'SUPERCOMPLETE_FILTER_REVERT'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_FILTER_PREFIX_MATCH'] = 126)] = + 'SUPERCOMPLETE_FILTER_PREFIX_MATCH'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_FILTER_SCORE_THRESHOLD'] = 127) + ] = 'SUPERCOMPLETE_FILTER_SCORE_THRESHOLD'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_FILTER_INSERTION_CAP'] = 128)] = + 'SUPERCOMPLETE_FILTER_INSERTION_CAP'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_FILTER_DELETION_CAP'] = 133)] = + 'SUPERCOMPLETE_FILTER_DELETION_CAP'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_FILTER_WHITESPACE_ONLY'] = 156) + ] = 'SUPERCOMPLETE_FILTER_WHITESPACE_ONLY'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_FILTER_NO_OP'] = 170)] = + 'SUPERCOMPLETE_FILTER_NO_OP'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_FILTER_SUFFIX_MATCH'] = 176)] = + 'SUPERCOMPLETE_FILTER_SUFFIX_MATCH'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_FILTER_PREVIOUSLY_SHOWN'] = 182) + ] = 'SUPERCOMPLETE_FILTER_PREVIOUSLY_SHOWN'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_MIN_SCORE'] = 129)] = + 'SUPERCOMPLETE_MIN_SCORE'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_MAX_INSERTIONS'] = 130)] = + 'SUPERCOMPLETE_MAX_INSERTIONS'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_LINE_RADIUS'] = 131)] = + 'SUPERCOMPLETE_LINE_RADIUS'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_MAX_DELETIONS'] = 132)] = + 'SUPERCOMPLETE_MAX_DELETIONS'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_USE_CURRENT_LINE'] = 135)] = + 'SUPERCOMPLETE_USE_CURRENT_LINE'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_RECENT_STEPS_DURATION'] = 138) + ] = 'SUPERCOMPLETE_RECENT_STEPS_DURATION'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_USE_CODE_DIAGNOSTICS'] = 143)] = + 'SUPERCOMPLETE_USE_CODE_DIAGNOSTICS'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_DIAGNOSTIC_SEVERITY_THRESHOLD'] = 223) + ] = 'SUPERCOMPLETE_DIAGNOSTIC_SEVERITY_THRESHOLD'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_CODE_DIAGNOSTICS_TOP_K'] = 232) + ] = 'SUPERCOMPLETE_CODE_DIAGNOSTICS_TOP_K'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_MAX_TRAJECTORY_STEPS'] = 154)] = + 'SUPERCOMPLETE_MAX_TRAJECTORY_STEPS'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_ON_ACCEPT_ONLY'] = 157)] = + 'SUPERCOMPLETE_ON_ACCEPT_ONLY'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_TEMPERATURE'] = 183)] = + 'SUPERCOMPLETE_TEMPERATURE'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_MAX_TRAJECTORY_STEP_SIZE'] = 203) + ] = 'SUPERCOMPLETE_MAX_TRAJECTORY_STEP_SIZE'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_DISABLE_TYPING_CACHE'] = 231)] = + 'SUPERCOMPLETE_DISABLE_TYPING_CACHE'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_ALWAYS_USE_CACHE_ON_EQUAL_STATE'] = 293) + ] = 'SUPERCOMPLETE_ALWAYS_USE_CACHE_ON_EQUAL_STATE'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_CACHE_ON_PARENT_ID_KILL_SWITCH'] = 297) + ] = 'SUPERCOMPLETE_CACHE_ON_PARENT_ID_KILL_SWITCH'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_PRUNE_RESPONSE'] = 140)] = + 'SUPERCOMPLETE_PRUNE_RESPONSE'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_PRUNE_MAX_INSERT_DELETE_LINE_DELTA'] = 141) + ] = 'SUPERCOMPLETE_PRUNE_MAX_INSERT_DELETE_LINE_DELTA'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_MODEL_CONFIG'] = 145)] = + 'SUPERCOMPLETE_MODEL_CONFIG'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_ON_TAB'] = 151)] = + 'SUPERCOMPLETE_ON_TAB'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_INLINE_PURE_DELETE'] = 171)] = + 'SUPERCOMPLETE_INLINE_PURE_DELETE'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_INLINE_RICH_GHOST_TEXT_INSERTIONS'] = 218) + ] = 'SUPERCOMPLETE_INLINE_RICH_GHOST_TEXT_INSERTIONS'; + ExperimentKey2[(ExperimentKey2['MODEL_CHAT_19821_VARIANTS'] = 308)] = + 'MODEL_CHAT_19821_VARIANTS'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_MAX_CONCURRENT_REQUESTS'] = 284) + ] = 'SUPERCOMPLETE_MAX_CONCURRENT_REQUESTS'; + ExperimentKey2[(ExperimentKey2['COMMAND_PROMPT_CACHE_CONFIG'] = 255)] = + 'COMMAND_PROMPT_CACHE_CONFIG'; + ExperimentKey2[(ExperimentKey2['CUMULATIVE_PROMPT_CONFIG'] = 256)] = + 'CUMULATIVE_PROMPT_CONFIG'; + ExperimentKey2[(ExperimentKey2['CUMULATIVE_PROMPT_CASCADE_CONFIG'] = 279)] = + 'CUMULATIVE_PROMPT_CASCADE_CONFIG'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_CUMULATIVE_PROMPT_CONFIG'] = 301)] = + 'TAB_JUMP_CUMULATIVE_PROMPT_CONFIG'; + ExperimentKey2[ + (ExperimentKey2['COMPLETION_SPEED_SUPERCOMPLETE_CACHE'] = 207) + ] = 'COMPLETION_SPEED_SUPERCOMPLETE_CACHE'; + ExperimentKey2[ + (ExperimentKey2['COMPLETION_SPEED_PREDICTIVE_SUPERCOMPLETE'] = 208) + ] = 'COMPLETION_SPEED_PREDICTIVE_SUPERCOMPLETE'; + ExperimentKey2[(ExperimentKey2['COMPLETION_SPEED_TAB_JUMP_CACHE'] = 209)] = + 'COMPLETION_SPEED_TAB_JUMP_CACHE'; + ExperimentKey2[ + (ExperimentKey2['COMPLETION_SPEED_PREDICTIVE_TAB_JUMP'] = 210) + ] = 'COMPLETION_SPEED_PREDICTIVE_TAB_JUMP'; + ExperimentKey2[ + (ExperimentKey2[ + 'COMPLETION_SPEED_BLOCK_TAB_JUMP_ON_PREDICTIVE_SUPERCOMPLETE' + ] = 294) + ] = 'COMPLETION_SPEED_BLOCK_TAB_JUMP_ON_PREDICTIVE_SUPERCOMPLETE'; + ExperimentKey2[(ExperimentKey2['JETBRAINS_ENABLE_ONBOARDING'] = 137)] = + 'JETBRAINS_ENABLE_ONBOARDING'; + ExperimentKey2[ + (ExperimentKey2['ENABLE_AUTOCOMPLETE_DURING_INTELLISENSE'] = 146) + ] = 'ENABLE_AUTOCOMPLETE_DURING_INTELLISENSE'; + ExperimentKey2[(ExperimentKey2['COMMAND_BOX_ON_TOP'] = 155)] = + 'COMMAND_BOX_ON_TOP'; + ExperimentKey2[(ExperimentKey2['CONTEXT_ACTIVE_DOCUMENT_FRACTION'] = 149)] = + 'CONTEXT_ACTIVE_DOCUMENT_FRACTION'; + ExperimentKey2[ + (ExperimentKey2['CONTEXT_COMMAND_TRAJECTORY_PROMPT_CONFIG'] = 150) + ] = 'CONTEXT_COMMAND_TRAJECTORY_PROMPT_CONFIG'; + ExperimentKey2[(ExperimentKey2['CONTEXT_FORCE_LOCAL_CONTEXT'] = 178)] = + 'CONTEXT_FORCE_LOCAL_CONTEXT'; + ExperimentKey2[ + (ExperimentKey2['CROSS_SELL_EXTENSION_DOWNLOAD_ANTIGRAVITY'] = 220) + ] = 'CROSS_SELL_EXTENSION_DOWNLOAD_ANTIGRAVITY'; + ExperimentKey2[ + (ExperimentKey2['MODEL_LLAMA_3_1_70B_INSTRUCT_LONG_CONTEXT_VARIANTS'] = 295) + ] = 'MODEL_LLAMA_3_1_70B_INSTRUCT_LONG_CONTEXT_VARIANTS'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_NO_ACTIVE_NODE'] = 166)] = + 'SUPERCOMPLETE_NO_ACTIVE_NODE'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_ENABLED'] = 168)] = + 'TAB_JUMP_ENABLED'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_LINE_RADIUS'] = 177)] = + 'TAB_JUMP_LINE_RADIUS'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_MIN_FILTER_RADIUS'] = 197)] = + 'TAB_JUMP_MIN_FILTER_RADIUS'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_ON_ACCEPT_ONLY'] = 205)] = + 'TAB_JUMP_ON_ACCEPT_ONLY'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_FILTER_IN_SELECTION'] = 215)] = + 'TAB_JUMP_FILTER_IN_SELECTION'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_MODEL_CONFIG'] = 237)] = + 'TAB_JUMP_MODEL_CONFIG'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_FILTER_NO_OP'] = 238)] = + 'TAB_JUMP_FILTER_NO_OP'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_FILTER_REVERT'] = 239)] = + 'TAB_JUMP_FILTER_REVERT'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_FILTER_SCORE_THRESHOLD'] = 240)] = + 'TAB_JUMP_FILTER_SCORE_THRESHOLD'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_FILTER_WHITESPACE_ONLY'] = 241)] = + 'TAB_JUMP_FILTER_WHITESPACE_ONLY'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_FILTER_INSERTION_CAP'] = 242)] = + 'TAB_JUMP_FILTER_INSERTION_CAP'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_FILTER_DELETION_CAP'] = 243)] = + 'TAB_JUMP_FILTER_DELETION_CAP'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_PRUNE_RESPONSE'] = 260)] = + 'TAB_JUMP_PRUNE_RESPONSE'; + ExperimentKey2[ + (ExperimentKey2['TAB_JUMP_PRUNE_MAX_INSERT_DELETE_LINE_DELTA'] = 261) + ] = 'TAB_JUMP_PRUNE_MAX_INSERT_DELETE_LINE_DELTA'; + ExperimentKey2[(ExperimentKey2['TAB_JUMP_STOP_TOKEN_MIDSTREAM'] = 317)] = + 'TAB_JUMP_STOP_TOKEN_MIDSTREAM'; + ExperimentKey2[(ExperimentKey2['VIEWED_FILE_TRACKER_CONFIG'] = 211)] = + 'VIEWED_FILE_TRACKER_CONFIG'; + ExperimentKey2[(ExperimentKey2['SNAPSHOT_TO_STEP_OPTIONS_OVERRIDE'] = 305)] = + 'SNAPSHOT_TO_STEP_OPTIONS_OVERRIDE'; + ExperimentKey2[(ExperimentKey2['STREAMING_EXTERNAL_COMMAND'] = 172)] = + 'STREAMING_EXTERNAL_COMMAND'; + ExperimentKey2[(ExperimentKey2['USE_SPECIAL_EDIT_CODE_BLOCK'] = 179)] = + 'USE_SPECIAL_EDIT_CODE_BLOCK'; + ExperimentKey2[(ExperimentKey2['ENABLE_SUGGESTED_RESPONSES'] = 187)] = + 'ENABLE_SUGGESTED_RESPONSES'; + ExperimentKey2[(ExperimentKey2['CASCADE_BASE_MODEL_ID'] = 190)] = + 'CASCADE_BASE_MODEL_ID'; + ExperimentKey2[(ExperimentKey2['CASCADE_PLAN_BASED_CONFIG_OVERRIDE'] = 266)] = + 'CASCADE_PLAN_BASED_CONFIG_OVERRIDE'; + ExperimentKey2[(ExperimentKey2['CASCADE_GLOBAL_CONFIG_OVERRIDE'] = 212)] = + 'CASCADE_GLOBAL_CONFIG_OVERRIDE'; + ExperimentKey2[ + (ExperimentKey2['CASCADE_BACKGROUND_RESEARCH_CONFIG_OVERRIDE'] = 193) + ] = 'CASCADE_BACKGROUND_RESEARCH_CONFIG_OVERRIDE'; + ExperimentKey2[(ExperimentKey2['CASCADE_ENFORCE_QUOTA'] = 204)] = + 'CASCADE_ENFORCE_QUOTA'; + ExperimentKey2[(ExperimentKey2['CASCADE_ENABLE_AUTOMATED_MEMORIES'] = 224)] = + 'CASCADE_ENABLE_AUTOMATED_MEMORIES'; + ExperimentKey2[(ExperimentKey2['CASCADE_MEMORY_CONFIG_OVERRIDE'] = 314)] = + 'CASCADE_MEMORY_CONFIG_OVERRIDE'; + ExperimentKey2[ + (ExperimentKey2['CASCADE_USE_REPLACE_CONTENT_EDIT_TOOL'] = 228) + ] = 'CASCADE_USE_REPLACE_CONTENT_EDIT_TOOL'; + ExperimentKey2[ + (ExperimentKey2['CASCADE_VIEW_FILE_TOOL_CONFIG_OVERRIDE'] = 258) + ] = 'CASCADE_VIEW_FILE_TOOL_CONFIG_OVERRIDE'; + ExperimentKey2[ + (ExperimentKey2['CASCADE_USE_EXPERIMENT_CHECKPOINTER'] = 247) + ] = 'CASCADE_USE_EXPERIMENT_CHECKPOINTER'; + ExperimentKey2[(ExperimentKey2['CASCADE_ENABLE_MCP_TOOLS'] = 245)] = + 'CASCADE_ENABLE_MCP_TOOLS'; + ExperimentKey2[(ExperimentKey2['CASCADE_AUTO_FIX_LINTS'] = 275)] = + 'CASCADE_AUTO_FIX_LINTS'; + ExperimentKey2[ + (ExperimentKey2['USE_ANTHROPIC_TOKEN_EFFICIENT_TOOLS_BETA'] = 296) + ] = 'USE_ANTHROPIC_TOKEN_EFFICIENT_TOOLS_BETA'; + ExperimentKey2[ + (ExperimentKey2['CASCADE_USER_MEMORIES_IN_SYS_PROMPT'] = 289) + ] = 'CASCADE_USER_MEMORIES_IN_SYS_PROMPT'; + ExperimentKey2[(ExperimentKey2['COLLAPSE_ASSISTANT_MESSAGES'] = 312)] = + 'COLLAPSE_ASSISTANT_MESSAGES'; + ExperimentKey2[(ExperimentKey2['CASCADE_DEFAULT_MODEL_OVERRIDE'] = 321)] = + 'CASCADE_DEFAULT_MODEL_OVERRIDE'; + ExperimentKey2[(ExperimentKey2['ENABLE_SMART_COPY'] = 181)] = + 'ENABLE_SMART_COPY'; + ExperimentKey2[(ExperimentKey2['ENABLE_COMMIT_MESSAGE_GENERATION'] = 185)] = + 'ENABLE_COMMIT_MESSAGE_GENERATION'; + ExperimentKey2[(ExperimentKey2['FIREWORKS_ON_DEMAND_DEPLOYMENT'] = 276)] = + 'FIREWORKS_ON_DEMAND_DEPLOYMENT'; + ExperimentKey2[(ExperimentKey2['API_SERVER_CLIENT_USE_HTTP_2'] = 202)] = + 'API_SERVER_CLIENT_USE_HTTP_2'; + ExperimentKey2[(ExperimentKey2['AUTOCOMPLETE_DEFAULT_DEBOUNCE_MS'] = 213)] = + 'AUTOCOMPLETE_DEFAULT_DEBOUNCE_MS'; + ExperimentKey2[(ExperimentKey2['AUTOCOMPLETE_FAST_DEBOUNCE_MS'] = 214)] = + 'AUTOCOMPLETE_FAST_DEBOUNCE_MS'; + ExperimentKey2[(ExperimentKey2['PROFILING_TELEMETRY_SAMPLE_RATE'] = 219)] = + 'PROFILING_TELEMETRY_SAMPLE_RATE'; + ExperimentKey2[(ExperimentKey2['STREAM_USER_SHELL_COMMANDS'] = 225)] = + 'STREAM_USER_SHELL_COMMANDS'; + ExperimentKey2[(ExperimentKey2['API_SERVER_PROMPT_CACHE_REPLICAS'] = 307)] = + 'API_SERVER_PROMPT_CACHE_REPLICAS'; + ExperimentKey2[(ExperimentKey2['API_SERVER_ENABLE_MORE_LOGGING'] = 272)] = + 'API_SERVER_ENABLE_MORE_LOGGING'; + ExperimentKey2[(ExperimentKey2['COMMAND_INJECT_USER_MEMORIES'] = 233)] = + 'COMMAND_INJECT_USER_MEMORIES'; + ExperimentKey2[(ExperimentKey2['AUTOCOMPLETE_HIDDEN_ERROR_REGEX'] = 234)] = + 'AUTOCOMPLETE_HIDDEN_ERROR_REGEX'; + ExperimentKey2[(ExperimentKey2['DISABLE_IDE_COMPLETIONS_DEBOUNCE'] = 278)] = + 'DISABLE_IDE_COMPLETIONS_DEBOUNCE'; + ExperimentKey2[ + (ExperimentKey2['COMBINED_MODEL_USE_FULL_INSTRUCTION_FOR_RETRIEVAL'] = 264) + ] = 'COMBINED_MODEL_USE_FULL_INSTRUCTION_FOR_RETRIEVAL'; + ExperimentKey2[ + (ExperimentKey2['MAX_PAST_TRAJECTORY_TOKENS_FOR_RETRIEVAL'] = 265) + ] = 'MAX_PAST_TRAJECTORY_TOKENS_FOR_RETRIEVAL'; + ExperimentKey2[(ExperimentKey2['ENABLE_QUICK_ACTIONS'] = 250)] = + 'ENABLE_QUICK_ACTIONS'; + ExperimentKey2[(ExperimentKey2['QUICK_ACTIONS_WHITELIST_REGEX'] = 251)] = + 'QUICK_ACTIONS_WHITELIST_REGEX'; + ExperimentKey2[(ExperimentKey2['CASCADE_NEW_MODELS_NUX'] = 259)] = + 'CASCADE_NEW_MODELS_NUX'; + ExperimentKey2[(ExperimentKey2['CASCADE_NEW_WAVE_2_MODELS_NUX'] = 270)] = + 'CASCADE_NEW_WAVE_2_MODELS_NUX'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_FAST_DEBOUNCE'] = 262)] = + 'SUPERCOMPLETE_FAST_DEBOUNCE'; + ExperimentKey2[(ExperimentKey2['SUPERCOMPLETE_REGULAR_DEBOUNCE'] = 263)] = + 'SUPERCOMPLETE_REGULAR_DEBOUNCE'; + ExperimentKey2[(ExperimentKey2['XML_TOOL_PARSING_MODELS'] = 268)] = + 'XML_TOOL_PARSING_MODELS'; + ExperimentKey2[ + (ExperimentKey2['SUPERCOMPLETE_DONT_FILTER_MID_STREAMED'] = 269) + ] = 'SUPERCOMPLETE_DONT_FILTER_MID_STREAMED'; + ExperimentKey2[ + (ExperimentKey2['ANNOYANCE_MANAGER_MAX_NAVIGATION_RENDERS'] = 285) + ] = 'ANNOYANCE_MANAGER_MAX_NAVIGATION_RENDERS'; + ExperimentKey2[ + (ExperimentKey2['ANNOYANCE_MANAGER_INLINE_PREVENTION_THRESHOLD_MS'] = 286) + ] = 'ANNOYANCE_MANAGER_INLINE_PREVENTION_THRESHOLD_MS'; + ExperimentKey2[ + (ExperimentKey2[ + 'ANNOYANCE_MANAGER_INLINE_PREVENTION_MAX_INTENTIONAL_REJECTIONS' + ] = 287) + ] = 'ANNOYANCE_MANAGER_INLINE_PREVENTION_MAX_INTENTIONAL_REJECTIONS'; + ExperimentKey2[ + (ExperimentKey2['ANNOYANCE_MANAGER_INLINE_PREVENTION_MAX_AUTO_REJECTIONS'] = + 288) + ] = 'ANNOYANCE_MANAGER_INLINE_PREVENTION_MAX_AUTO_REJECTIONS'; + ExperimentKey2[(ExperimentKey2['USE_CUSTOM_CHARACTER_DIFF'] = 292)] = + 'USE_CUSTOM_CHARACTER_DIFF'; + ExperimentKey2[(ExperimentKey2['FORCE_NON_OPTIMIZED_DIFF'] = 298)] = + 'FORCE_NON_OPTIMIZED_DIFF'; + ExperimentKey2[ + (ExperimentKey2['CASCADE_RECIPES_AT_MENTION_VISIBILITY'] = 316) + ] = 'CASCADE_RECIPES_AT_MENTION_VISIBILITY'; + ExperimentKey2[(ExperimentKey2['IMPLICIT_USES_CLIPBOARD'] = 310)] = + 'IMPLICIT_USES_CLIPBOARD'; + ExperimentKey2[(ExperimentKey2['DISABLE_SUPERCOMPLETE_PCW'] = 303)] = + 'DISABLE_SUPERCOMPLETE_PCW'; + ExperimentKey2[(ExperimentKey2['BLOCK_TAB_ON_SHOWN_AUTOCOMPLETE'] = 304)] = + 'BLOCK_TAB_ON_SHOWN_AUTOCOMPLETE'; + ExperimentKey2[(ExperimentKey2['CASCADE_WEB_SEARCH_NUX'] = 311)] = + 'CASCADE_WEB_SEARCH_NUX'; + ExperimentKey2[(ExperimentKey2['MODEL_NOTIFICATIONS'] = 319)] = + 'MODEL_NOTIFICATIONS'; + ExperimentKey2[(ExperimentKey2['MODEL_SELECTOR_NUX_COPY'] = 320)] = + 'MODEL_SELECTOR_NUX_COPY'; + ExperimentKey2[(ExperimentKey2['CASCADE_TOOL_CALL_PRICING_NUX'] = 322)] = + 'CASCADE_TOOL_CALL_PRICING_NUX'; + ExperimentKey2[(ExperimentKey2['CASCADE_PLUGINS_TAB'] = 323)] = + 'CASCADE_PLUGINS_TAB'; + ExperimentKey2[(ExperimentKey2['WAVE_8_RULES_ENABLED'] = 324)] = + 'WAVE_8_RULES_ENABLED'; + ExperimentKey2[(ExperimentKey2['WAVE_8_KNOWLEDGE_ENABLED'] = 325)] = + 'WAVE_8_KNOWLEDGE_ENABLED'; + ExperimentKey2[(ExperimentKey2['CASCADE_ONBOARDING'] = 326)] = + 'CASCADE_ONBOARDING'; + ExperimentKey2[(ExperimentKey2['CASCADE_ONBOARDING_REVERT'] = 327)] = + 'CASCADE_ONBOARDING_REVERT'; + ExperimentKey2[ + (ExperimentKey2['CASCADE_ANTIGRAVITY_BROWSER_TOOLS_ENABLED'] = 328) + ] = 'CASCADE_ANTIGRAVITY_BROWSER_TOOLS_ENABLED'; + ExperimentKey2[(ExperimentKey2['CASCADE_MODEL_HEADER_WARNING'] = 329)] = + 'CASCADE_MODEL_HEADER_WARNING'; + ExperimentKey2[(ExperimentKey2['LOG_CASCADE_CHAT_PANEL_ERROR'] = 331)] = + 'LOG_CASCADE_CHAT_PANEL_ERROR'; + ExperimentKey2[(ExperimentKey2['TEST_ONLY'] = 999)] = 'TEST_ONLY'; +})(ExperimentKey || (ExperimentKey = {})); +proto3.util.setEnumType(ExperimentKey, 'exa.codeium_common_pb.ExperimentKey', [ + { no: 0, name: 'UNSPECIFIED' }, + { no: 36, name: 'USE_INTERNAL_CHAT_MODEL' }, + { no: 47, name: 'RECORD_FILES' }, + { no: 48, name: 'NO_SAMPLER_EARLY_STOP' }, + { no: 53, name: 'CM_MEMORY_TELEMETRY' }, + { no: 55, name: 'LANGUAGE_SERVER_VERSION' }, + { no: 56, name: 'LANGUAGE_SERVER_AUTO_RELOAD' }, + { no: 60, name: 'ONLY_MULTILINE' }, + { no: 68, name: 'USE_ATTRIBUTION_FOR_INDIVIDUAL_TIER' }, + { no: 78, name: 'CHAT_MODEL_CONFIG' }, + { no: 79, name: 'COMMAND_MODEL_CONFIG' }, + { no: 81, name: 'MIN_IDE_VERSION' }, + { no: 84, name: 'API_SERVER_VERBOSE_ERRORS' }, + { no: 86, name: 'DEFAULT_ENABLE_SEARCH' }, + { no: 87, name: 'COLLECT_ONBOARDING_EVENTS' }, + { no: 88, name: 'COLLECT_EXAMPLE_COMPLETIONS' }, + { no: 89, name: 'USE_MULTILINE_MODEL' }, + { no: 92, name: 'ATTRIBUTION_KILL_SWITCH' }, + { no: 94, name: 'FAST_MULTILINE' }, + { no: 95, name: 'SINGLE_COMPLETION' }, + { no: 96, name: 'STOP_FIRST_NON_WHITESPACE_LINE' }, + { no: 102, name: 'CORTEX_CONFIG' }, + { no: 103, name: 'MODEL_CHAT_11121_VARIANTS' }, + { no: 105, name: 'INCLUDE_PROMPT_COMPONENTS' }, + { no: 108, name: 'PERSIST_CODE_TRACKER' }, + { no: 112, name: 'API_SERVER_LIVENESS_PROBE' }, + { no: 114, name: 'CHAT_COMPLETION_TOKENS_SOFT_LIMIT' }, + { no: 115, name: 'CHAT_TOKENS_SOFT_LIMIT' }, + { no: 118, name: 'DISABLE_COMPLETIONS_CACHE' }, + { no: 119, name: 'LLAMA3_405B_KILL_SWITCH' }, + { no: 121, name: 'USE_COMMAND_DOCSTRING_GENERATION' }, + { no: 136, name: 'SENTRY' }, + { no: 144, name: 'FAST_SINGLELINE' }, + { no: 147, name: 'R2_LANGUAGE_SERVER_DOWNLOAD' }, + { no: 152, name: 'SPLIT_MODEL' }, + { no: 198, name: 'ANTIGRAVITY_SENTRY_SAMPLE_RATE' }, + { no: 158, name: 'API_SERVER_CUTOFF' }, + { no: 159, name: 'FAST_SPEED_KILL_SWITCH' }, + { no: 160, name: 'PREDICTIVE_MULTILINE' }, + { no: 125, name: 'SUPERCOMPLETE_FILTER_REVERT' }, + { no: 126, name: 'SUPERCOMPLETE_FILTER_PREFIX_MATCH' }, + { no: 127, name: 'SUPERCOMPLETE_FILTER_SCORE_THRESHOLD' }, + { no: 128, name: 'SUPERCOMPLETE_FILTER_INSERTION_CAP' }, + { no: 133, name: 'SUPERCOMPLETE_FILTER_DELETION_CAP' }, + { no: 156, name: 'SUPERCOMPLETE_FILTER_WHITESPACE_ONLY' }, + { no: 170, name: 'SUPERCOMPLETE_FILTER_NO_OP' }, + { no: 176, name: 'SUPERCOMPLETE_FILTER_SUFFIX_MATCH' }, + { no: 182, name: 'SUPERCOMPLETE_FILTER_PREVIOUSLY_SHOWN' }, + { no: 129, name: 'SUPERCOMPLETE_MIN_SCORE' }, + { no: 130, name: 'SUPERCOMPLETE_MAX_INSERTIONS' }, + { no: 131, name: 'SUPERCOMPLETE_LINE_RADIUS' }, + { no: 132, name: 'SUPERCOMPLETE_MAX_DELETIONS' }, + { no: 135, name: 'SUPERCOMPLETE_USE_CURRENT_LINE' }, + { no: 138, name: 'SUPERCOMPLETE_RECENT_STEPS_DURATION' }, + { no: 143, name: 'SUPERCOMPLETE_USE_CODE_DIAGNOSTICS' }, + { no: 223, name: 'SUPERCOMPLETE_DIAGNOSTIC_SEVERITY_THRESHOLD' }, + { no: 232, name: 'SUPERCOMPLETE_CODE_DIAGNOSTICS_TOP_K' }, + { no: 154, name: 'SUPERCOMPLETE_MAX_TRAJECTORY_STEPS' }, + { no: 157, name: 'SUPERCOMPLETE_ON_ACCEPT_ONLY' }, + { no: 183, name: 'SUPERCOMPLETE_TEMPERATURE' }, + { no: 203, name: 'SUPERCOMPLETE_MAX_TRAJECTORY_STEP_SIZE' }, + { no: 231, name: 'SUPERCOMPLETE_DISABLE_TYPING_CACHE' }, + { no: 293, name: 'SUPERCOMPLETE_ALWAYS_USE_CACHE_ON_EQUAL_STATE' }, + { no: 297, name: 'SUPERCOMPLETE_CACHE_ON_PARENT_ID_KILL_SWITCH' }, + { no: 140, name: 'SUPERCOMPLETE_PRUNE_RESPONSE' }, + { no: 141, name: 'SUPERCOMPLETE_PRUNE_MAX_INSERT_DELETE_LINE_DELTA' }, + { no: 145, name: 'SUPERCOMPLETE_MODEL_CONFIG' }, + { no: 151, name: 'SUPERCOMPLETE_ON_TAB' }, + { no: 171, name: 'SUPERCOMPLETE_INLINE_PURE_DELETE' }, + { no: 218, name: 'SUPERCOMPLETE_INLINE_RICH_GHOST_TEXT_INSERTIONS' }, + { no: 308, name: 'MODEL_CHAT_19821_VARIANTS' }, + { no: 284, name: 'SUPERCOMPLETE_MAX_CONCURRENT_REQUESTS' }, + { no: 255, name: 'COMMAND_PROMPT_CACHE_CONFIG' }, + { no: 256, name: 'CUMULATIVE_PROMPT_CONFIG' }, + { no: 279, name: 'CUMULATIVE_PROMPT_CASCADE_CONFIG' }, + { no: 301, name: 'TAB_JUMP_CUMULATIVE_PROMPT_CONFIG' }, + { no: 207, name: 'COMPLETION_SPEED_SUPERCOMPLETE_CACHE' }, + { no: 208, name: 'COMPLETION_SPEED_PREDICTIVE_SUPERCOMPLETE' }, + { no: 209, name: 'COMPLETION_SPEED_TAB_JUMP_CACHE' }, + { no: 210, name: 'COMPLETION_SPEED_PREDICTIVE_TAB_JUMP' }, + { + no: 294, + name: 'COMPLETION_SPEED_BLOCK_TAB_JUMP_ON_PREDICTIVE_SUPERCOMPLETE', + }, + { no: 137, name: 'JETBRAINS_ENABLE_ONBOARDING' }, + { no: 146, name: 'ENABLE_AUTOCOMPLETE_DURING_INTELLISENSE' }, + { no: 155, name: 'COMMAND_BOX_ON_TOP' }, + { no: 149, name: 'CONTEXT_ACTIVE_DOCUMENT_FRACTION' }, + { no: 150, name: 'CONTEXT_COMMAND_TRAJECTORY_PROMPT_CONFIG' }, + { no: 178, name: 'CONTEXT_FORCE_LOCAL_CONTEXT' }, + { no: 220, name: 'CROSS_SELL_EXTENSION_DOWNLOAD_ANTIGRAVITY' }, + { no: 295, name: 'MODEL_LLAMA_3_1_70B_INSTRUCT_LONG_CONTEXT_VARIANTS' }, + { no: 166, name: 'SUPERCOMPLETE_NO_ACTIVE_NODE' }, + { no: 168, name: 'TAB_JUMP_ENABLED' }, + { no: 177, name: 'TAB_JUMP_LINE_RADIUS' }, + { no: 197, name: 'TAB_JUMP_MIN_FILTER_RADIUS' }, + { no: 205, name: 'TAB_JUMP_ON_ACCEPT_ONLY' }, + { no: 215, name: 'TAB_JUMP_FILTER_IN_SELECTION' }, + { no: 237, name: 'TAB_JUMP_MODEL_CONFIG' }, + { no: 238, name: 'TAB_JUMP_FILTER_NO_OP' }, + { no: 239, name: 'TAB_JUMP_FILTER_REVERT' }, + { no: 240, name: 'TAB_JUMP_FILTER_SCORE_THRESHOLD' }, + { no: 241, name: 'TAB_JUMP_FILTER_WHITESPACE_ONLY' }, + { no: 242, name: 'TAB_JUMP_FILTER_INSERTION_CAP' }, + { no: 243, name: 'TAB_JUMP_FILTER_DELETION_CAP' }, + { no: 260, name: 'TAB_JUMP_PRUNE_RESPONSE' }, + { no: 261, name: 'TAB_JUMP_PRUNE_MAX_INSERT_DELETE_LINE_DELTA' }, + { no: 317, name: 'TAB_JUMP_STOP_TOKEN_MIDSTREAM' }, + { no: 211, name: 'VIEWED_FILE_TRACKER_CONFIG' }, + { no: 305, name: 'SNAPSHOT_TO_STEP_OPTIONS_OVERRIDE' }, + { no: 172, name: 'STREAMING_EXTERNAL_COMMAND' }, + { no: 179, name: 'USE_SPECIAL_EDIT_CODE_BLOCK' }, + { no: 187, name: 'ENABLE_SUGGESTED_RESPONSES' }, + { no: 190, name: 'CASCADE_BASE_MODEL_ID' }, + { no: 266, name: 'CASCADE_PLAN_BASED_CONFIG_OVERRIDE' }, + { no: 212, name: 'CASCADE_GLOBAL_CONFIG_OVERRIDE' }, + { no: 193, name: 'CASCADE_BACKGROUND_RESEARCH_CONFIG_OVERRIDE' }, + { no: 204, name: 'CASCADE_ENFORCE_QUOTA' }, + { no: 224, name: 'CASCADE_ENABLE_AUTOMATED_MEMORIES' }, + { no: 314, name: 'CASCADE_MEMORY_CONFIG_OVERRIDE' }, + { no: 228, name: 'CASCADE_USE_REPLACE_CONTENT_EDIT_TOOL' }, + { no: 258, name: 'CASCADE_VIEW_FILE_TOOL_CONFIG_OVERRIDE' }, + { no: 247, name: 'CASCADE_USE_EXPERIMENT_CHECKPOINTER' }, + { no: 245, name: 'CASCADE_ENABLE_MCP_TOOLS' }, + { no: 275, name: 'CASCADE_AUTO_FIX_LINTS' }, + { no: 296, name: 'USE_ANTHROPIC_TOKEN_EFFICIENT_TOOLS_BETA' }, + { no: 289, name: 'CASCADE_USER_MEMORIES_IN_SYS_PROMPT' }, + { no: 312, name: 'COLLAPSE_ASSISTANT_MESSAGES' }, + { no: 321, name: 'CASCADE_DEFAULT_MODEL_OVERRIDE' }, + { no: 181, name: 'ENABLE_SMART_COPY' }, + { no: 185, name: 'ENABLE_COMMIT_MESSAGE_GENERATION' }, + { no: 276, name: 'FIREWORKS_ON_DEMAND_DEPLOYMENT' }, + { no: 202, name: 'API_SERVER_CLIENT_USE_HTTP_2' }, + { no: 213, name: 'AUTOCOMPLETE_DEFAULT_DEBOUNCE_MS' }, + { no: 214, name: 'AUTOCOMPLETE_FAST_DEBOUNCE_MS' }, + { no: 219, name: 'PROFILING_TELEMETRY_SAMPLE_RATE' }, + { no: 225, name: 'STREAM_USER_SHELL_COMMANDS' }, + { no: 307, name: 'API_SERVER_PROMPT_CACHE_REPLICAS' }, + { no: 272, name: 'API_SERVER_ENABLE_MORE_LOGGING' }, + { no: 233, name: 'COMMAND_INJECT_USER_MEMORIES' }, + { no: 234, name: 'AUTOCOMPLETE_HIDDEN_ERROR_REGEX' }, + { no: 278, name: 'DISABLE_IDE_COMPLETIONS_DEBOUNCE' }, + { no: 264, name: 'COMBINED_MODEL_USE_FULL_INSTRUCTION_FOR_RETRIEVAL' }, + { no: 265, name: 'MAX_PAST_TRAJECTORY_TOKENS_FOR_RETRIEVAL' }, + { no: 250, name: 'ENABLE_QUICK_ACTIONS' }, + { no: 251, name: 'QUICK_ACTIONS_WHITELIST_REGEX' }, + { no: 259, name: 'CASCADE_NEW_MODELS_NUX' }, + { no: 270, name: 'CASCADE_NEW_WAVE_2_MODELS_NUX' }, + { no: 262, name: 'SUPERCOMPLETE_FAST_DEBOUNCE' }, + { no: 263, name: 'SUPERCOMPLETE_REGULAR_DEBOUNCE' }, + { no: 268, name: 'XML_TOOL_PARSING_MODELS' }, + { no: 269, name: 'SUPERCOMPLETE_DONT_FILTER_MID_STREAMED' }, + { no: 285, name: 'ANNOYANCE_MANAGER_MAX_NAVIGATION_RENDERS' }, + { no: 286, name: 'ANNOYANCE_MANAGER_INLINE_PREVENTION_THRESHOLD_MS' }, + { + no: 287, + name: 'ANNOYANCE_MANAGER_INLINE_PREVENTION_MAX_INTENTIONAL_REJECTIONS', + }, + { no: 288, name: 'ANNOYANCE_MANAGER_INLINE_PREVENTION_MAX_AUTO_REJECTIONS' }, + { no: 292, name: 'USE_CUSTOM_CHARACTER_DIFF' }, + { no: 298, name: 'FORCE_NON_OPTIMIZED_DIFF' }, + { no: 316, name: 'CASCADE_RECIPES_AT_MENTION_VISIBILITY' }, + { no: 310, name: 'IMPLICIT_USES_CLIPBOARD' }, + { no: 303, name: 'DISABLE_SUPERCOMPLETE_PCW' }, + { no: 304, name: 'BLOCK_TAB_ON_SHOWN_AUTOCOMPLETE' }, + { no: 311, name: 'CASCADE_WEB_SEARCH_NUX' }, + { no: 319, name: 'MODEL_NOTIFICATIONS' }, + { no: 320, name: 'MODEL_SELECTOR_NUX_COPY' }, + { no: 322, name: 'CASCADE_TOOL_CALL_PRICING_NUX' }, + { no: 323, name: 'CASCADE_PLUGINS_TAB' }, + { no: 324, name: 'WAVE_8_RULES_ENABLED' }, + { no: 325, name: 'WAVE_8_KNOWLEDGE_ENABLED' }, + { no: 326, name: 'CASCADE_ONBOARDING' }, + { no: 327, name: 'CASCADE_ONBOARDING_REVERT' }, + { no: 328, name: 'CASCADE_ANTIGRAVITY_BROWSER_TOOLS_ENABLED' }, + { no: 329, name: 'CASCADE_MODEL_HEADER_WARNING' }, + { no: 331, name: 'LOG_CASCADE_CHAT_PANEL_ERROR' }, + { no: 999, name: 'TEST_ONLY' }, +]); +var ExperimentSource; +(function (ExperimentSource2) { + ExperimentSource2[(ExperimentSource2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ExperimentSource2[(ExperimentSource2['EXTENSION'] = 1)] = 'EXTENSION'; + ExperimentSource2[(ExperimentSource2['LANGUAGE_SERVER'] = 2)] = + 'LANGUAGE_SERVER'; + ExperimentSource2[(ExperimentSource2['API_SERVER'] = 3)] = 'API_SERVER'; +})(ExperimentSource || (ExperimentSource = {})); +proto3.util.setEnumType( + ExperimentSource, + 'exa.codeium_common_pb.ExperimentSource', + [ + { no: 0, name: 'EXPERIMENT_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'EXPERIMENT_SOURCE_EXTENSION' }, + { no: 2, name: 'EXPERIMENT_SOURCE_LANGUAGE_SERVER' }, + { no: 3, name: 'EXPERIMENT_SOURCE_API_SERVER' }, + ], +); +var ModelAlias; +(function (ModelAlias2) { + ModelAlias2[(ModelAlias2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ModelAlias2[(ModelAlias2['CASCADE_BASE'] = 1)] = 'CASCADE_BASE'; + ModelAlias2[(ModelAlias2['VISTA'] = 3)] = 'VISTA'; + ModelAlias2[(ModelAlias2['SHAMU'] = 4)] = 'SHAMU'; + ModelAlias2[(ModelAlias2['SWE_1'] = 5)] = 'SWE_1'; + ModelAlias2[(ModelAlias2['SWE_1_LITE'] = 6)] = 'SWE_1_LITE'; + ModelAlias2[(ModelAlias2['AUTO'] = 7)] = 'AUTO'; + ModelAlias2[(ModelAlias2['RECOMMENDED'] = 8)] = 'RECOMMENDED'; +})(ModelAlias || (ModelAlias = {})); +proto3.util.setEnumType(ModelAlias, 'exa.codeium_common_pb.ModelAlias', [ + { no: 0, name: 'MODEL_ALIAS_UNSPECIFIED' }, + { no: 1, name: 'MODEL_ALIAS_CASCADE_BASE' }, + { no: 3, name: 'MODEL_ALIAS_VISTA' }, + { no: 4, name: 'MODEL_ALIAS_SHAMU' }, + { no: 5, name: 'MODEL_ALIAS_SWE_1' }, + { no: 6, name: 'MODEL_ALIAS_SWE_1_LITE' }, + { no: 7, name: 'MODEL_ALIAS_AUTO' }, + { no: 8, name: 'MODEL_ALIAS_RECOMMENDED' }, +]); +var Model; +(function (Model2) { + Model2[(Model2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + Model2[(Model2['CHAT_20706'] = 235)] = 'CHAT_20706'; + Model2[(Model2['CHAT_23310'] = 269)] = 'CHAT_23310'; + Model2[(Model2['GOOGLE_GEMINI_2_5_FLASH'] = 312)] = 'GOOGLE_GEMINI_2_5_FLASH'; + Model2[(Model2['GOOGLE_GEMINI_2_5_FLASH_THINKING'] = 313)] = + 'GOOGLE_GEMINI_2_5_FLASH_THINKING'; + Model2[(Model2['GOOGLE_GEMINI_2_5_FLASH_THINKING_TOOLS'] = 329)] = + 'GOOGLE_GEMINI_2_5_FLASH_THINKING_TOOLS'; + Model2[(Model2['GOOGLE_GEMINI_2_5_FLASH_LITE'] = 330)] = + 'GOOGLE_GEMINI_2_5_FLASH_LITE'; + Model2[(Model2['GOOGLE_GEMINI_2_5_PRO'] = 246)] = 'GOOGLE_GEMINI_2_5_PRO'; + Model2[(Model2['GOOGLE_GEMINI_2_5_PRO_EVAL'] = 331)] = + 'GOOGLE_GEMINI_2_5_PRO_EVAL'; + Model2[(Model2['GOOGLE_GEMINI_FOR_GOOGLE_2_5_PRO'] = 327)] = + 'GOOGLE_GEMINI_FOR_GOOGLE_2_5_PRO'; + Model2[(Model2['GOOGLE_GEMINI_NEMOSREEF'] = 328)] = 'GOOGLE_GEMINI_NEMOSREEF'; + Model2[(Model2['GOOGLE_GEMINI_2_5_FLASH_IMAGE_PREVIEW'] = 332)] = + 'GOOGLE_GEMINI_2_5_FLASH_IMAGE_PREVIEW'; + Model2[(Model2['GOOGLE_GEMINI_COMPUTER_USE_EXPERIMENTAL'] = 335)] = + 'GOOGLE_GEMINI_COMPUTER_USE_EXPERIMENTAL'; + Model2[(Model2['GOOGLE_GEMINI_RAINSONG'] = 339)] = 'GOOGLE_GEMINI_RAINSONG'; + Model2[(Model2['GOOGLE_JARVIS_PROXY'] = 346)] = 'GOOGLE_JARVIS_PROXY'; + Model2[(Model2['GOOGLE_JARVIS_V4S'] = 349)] = 'GOOGLE_JARVIS_V4S'; + Model2[(Model2['GOOGLE_GEMINI_TRAINING_POLICY'] = 323)] = + 'GOOGLE_GEMINI_TRAINING_POLICY'; + Model2[(Model2['GOOGLE_GEMINI_INTERNAL_BYOM'] = 326)] = + 'GOOGLE_GEMINI_INTERNAL_BYOM'; + Model2[(Model2['GOOGLE_GEMINI_INTERNAL_TAB_FLASH_LITE'] = 344)] = + 'GOOGLE_GEMINI_INTERNAL_TAB_FLASH_LITE'; + Model2[(Model2['GOOGLE_GEMINI_INTERNAL_TAB_JUMP_FLASH_LITE'] = 345)] = + 'GOOGLE_GEMINI_INTERNAL_TAB_JUMP_FLASH_LITE'; + Model2[(Model2['GOOGLE_GEMINI_HORIZONDAWN'] = 336)] = + 'GOOGLE_GEMINI_HORIZONDAWN'; + Model2[(Model2['GOOGLE_GEMINI_PUREPRISM'] = 337)] = 'GOOGLE_GEMINI_PUREPRISM'; + Model2[(Model2['GOOGLE_GEMINI_GENTLEISLAND'] = 338)] = + 'GOOGLE_GEMINI_GENTLEISLAND'; + Model2[(Model2['GOOGLE_GEMINI_ORIONFIRE'] = 343)] = 'GOOGLE_GEMINI_ORIONFIRE'; + Model2[(Model2['GOOGLE_GEMINI_COSMICFORGE'] = 347)] = + 'GOOGLE_GEMINI_COSMICFORGE'; + Model2[(Model2['GOOGLE_GEMINI_RIFTRUNNER'] = 348)] = + 'GOOGLE_GEMINI_RIFTRUNNER'; + Model2[(Model2['GOOGLE_GEMINI_RIFTRUNNER_THINKING_LOW'] = 352)] = + 'GOOGLE_GEMINI_RIFTRUNNER_THINKING_LOW'; + Model2[(Model2['GOOGLE_GEMINI_RIFTRUNNER_THINKING_HIGH'] = 353)] = + 'GOOGLE_GEMINI_RIFTRUNNER_THINKING_HIGH'; + Model2[(Model2['GOOGLE_GEMINI_INFINITYJET'] = 350)] = + 'GOOGLE_GEMINI_INFINITYJET'; + Model2[(Model2['GOOGLE_GEMINI_INFINITYBLOOM'] = 351)] = + 'GOOGLE_GEMINI_INFINITYBLOOM'; + Model2[(Model2['CLAUDE_4_SONNET'] = 281)] = 'CLAUDE_4_SONNET'; + Model2[(Model2['CLAUDE_4_SONNET_THINKING'] = 282)] = + 'CLAUDE_4_SONNET_THINKING'; + Model2[(Model2['CLAUDE_4_OPUS'] = 290)] = 'CLAUDE_4_OPUS'; + Model2[(Model2['CLAUDE_4_OPUS_THINKING'] = 291)] = 'CLAUDE_4_OPUS_THINKING'; + Model2[(Model2['CLAUDE_4_5_SONNET'] = 333)] = 'CLAUDE_4_5_SONNET'; + Model2[(Model2['CLAUDE_4_5_SONNET_THINKING'] = 334)] = + 'CLAUDE_4_5_SONNET_THINKING'; + Model2[(Model2['CLAUDE_4_5_HAIKU'] = 340)] = 'CLAUDE_4_5_HAIKU'; + Model2[(Model2['CLAUDE_4_5_HAIKU_THINKING'] = 341)] = + 'CLAUDE_4_5_HAIKU_THINKING'; + Model2[(Model2['OPENAI_GPT_OSS_120B_MEDIUM'] = 342)] = + 'OPENAI_GPT_OSS_120B_MEDIUM'; + Model2[(Model2['PLACEHOLDER_M0'] = 1e3)] = 'PLACEHOLDER_M0'; + Model2[(Model2['PLACEHOLDER_M1'] = 1001)] = 'PLACEHOLDER_M1'; + Model2[(Model2['PLACEHOLDER_M2'] = 1002)] = 'PLACEHOLDER_M2'; + Model2[(Model2['PLACEHOLDER_M3'] = 1003)] = 'PLACEHOLDER_M3'; + Model2[(Model2['PLACEHOLDER_M4'] = 1004)] = 'PLACEHOLDER_M4'; + Model2[(Model2['PLACEHOLDER_M5'] = 1005)] = 'PLACEHOLDER_M5'; + Model2[(Model2['PLACEHOLDER_M6'] = 1006)] = 'PLACEHOLDER_M6'; + Model2[(Model2['PLACEHOLDER_M7'] = 1007)] = 'PLACEHOLDER_M7'; + Model2[(Model2['PLACEHOLDER_M8'] = 1008)] = 'PLACEHOLDER_M8'; + Model2[(Model2['PLACEHOLDER_M9'] = 1009)] = 'PLACEHOLDER_M9'; + Model2[(Model2['PLACEHOLDER_M10'] = 1010)] = 'PLACEHOLDER_M10'; + Model2[(Model2['PLACEHOLDER_M11'] = 1011)] = 'PLACEHOLDER_M11'; + Model2[(Model2['PLACEHOLDER_M12'] = 1012)] = 'PLACEHOLDER_M12'; + Model2[(Model2['PLACEHOLDER_M13'] = 1013)] = 'PLACEHOLDER_M13'; + Model2[(Model2['PLACEHOLDER_M14'] = 1014)] = 'PLACEHOLDER_M14'; + Model2[(Model2['PLACEHOLDER_M15'] = 1015)] = 'PLACEHOLDER_M15'; + Model2[(Model2['PLACEHOLDER_M16'] = 1016)] = 'PLACEHOLDER_M16'; + Model2[(Model2['PLACEHOLDER_M17'] = 1017)] = 'PLACEHOLDER_M17'; + Model2[(Model2['PLACEHOLDER_M18'] = 1018)] = 'PLACEHOLDER_M18'; + Model2[(Model2['PLACEHOLDER_M19'] = 1019)] = 'PLACEHOLDER_M19'; + Model2[(Model2['PLACEHOLDER_M20'] = 1020)] = 'PLACEHOLDER_M20'; + Model2[(Model2['PLACEHOLDER_M21'] = 1021)] = 'PLACEHOLDER_M21'; + Model2[(Model2['PLACEHOLDER_M22'] = 1022)] = 'PLACEHOLDER_M22'; + Model2[(Model2['PLACEHOLDER_M23'] = 1023)] = 'PLACEHOLDER_M23'; + Model2[(Model2['PLACEHOLDER_M24'] = 1024)] = 'PLACEHOLDER_M24'; + Model2[(Model2['PLACEHOLDER_M25'] = 1025)] = 'PLACEHOLDER_M25'; + Model2[(Model2['PLACEHOLDER_M26'] = 1026)] = 'PLACEHOLDER_M26'; + Model2[(Model2['PLACEHOLDER_M27'] = 1027)] = 'PLACEHOLDER_M27'; + Model2[(Model2['PLACEHOLDER_M28'] = 1028)] = 'PLACEHOLDER_M28'; + Model2[(Model2['PLACEHOLDER_M29'] = 1029)] = 'PLACEHOLDER_M29'; + Model2[(Model2['PLACEHOLDER_M30'] = 1030)] = 'PLACEHOLDER_M30'; + Model2[(Model2['PLACEHOLDER_M31'] = 1031)] = 'PLACEHOLDER_M31'; + Model2[(Model2['PLACEHOLDER_M32'] = 1032)] = 'PLACEHOLDER_M32'; + Model2[(Model2['PLACEHOLDER_M33'] = 1033)] = 'PLACEHOLDER_M33'; + Model2[(Model2['PLACEHOLDER_M34'] = 1034)] = 'PLACEHOLDER_M34'; + Model2[(Model2['PLACEHOLDER_M35'] = 1035)] = 'PLACEHOLDER_M35'; + Model2[(Model2['PLACEHOLDER_M36'] = 1036)] = 'PLACEHOLDER_M36'; + Model2[(Model2['PLACEHOLDER_M37'] = 1037)] = 'PLACEHOLDER_M37'; + Model2[(Model2['PLACEHOLDER_M38'] = 1038)] = 'PLACEHOLDER_M38'; + Model2[(Model2['PLACEHOLDER_M39'] = 1039)] = 'PLACEHOLDER_M39'; + Model2[(Model2['PLACEHOLDER_M40'] = 1040)] = 'PLACEHOLDER_M40'; + Model2[(Model2['PLACEHOLDER_M41'] = 1041)] = 'PLACEHOLDER_M41'; + Model2[(Model2['PLACEHOLDER_M42'] = 1042)] = 'PLACEHOLDER_M42'; + Model2[(Model2['PLACEHOLDER_M43'] = 1043)] = 'PLACEHOLDER_M43'; + Model2[(Model2['PLACEHOLDER_M44'] = 1044)] = 'PLACEHOLDER_M44'; + Model2[(Model2['PLACEHOLDER_M45'] = 1045)] = 'PLACEHOLDER_M45'; + Model2[(Model2['PLACEHOLDER_M46'] = 1046)] = 'PLACEHOLDER_M46'; + Model2[(Model2['PLACEHOLDER_M47'] = 1047)] = 'PLACEHOLDER_M47'; + Model2[(Model2['PLACEHOLDER_M48'] = 1048)] = 'PLACEHOLDER_M48'; + Model2[(Model2['PLACEHOLDER_M49'] = 1049)] = 'PLACEHOLDER_M49'; + Model2[(Model2['PLACEHOLDER_M50'] = 1050)] = 'PLACEHOLDER_M50'; +})(Model || (Model = {})); +proto3.util.setEnumType(Model, 'exa.codeium_common_pb.Model', [ + { no: 0, name: 'MODEL_UNSPECIFIED' }, + { no: 235, name: 'MODEL_CHAT_20706' }, + { no: 269, name: 'MODEL_CHAT_23310' }, + { no: 312, name: 'MODEL_GOOGLE_GEMINI_2_5_FLASH' }, + { no: 313, name: 'MODEL_GOOGLE_GEMINI_2_5_FLASH_THINKING' }, + { no: 329, name: 'MODEL_GOOGLE_GEMINI_2_5_FLASH_THINKING_TOOLS' }, + { no: 330, name: 'MODEL_GOOGLE_GEMINI_2_5_FLASH_LITE' }, + { no: 246, name: 'MODEL_GOOGLE_GEMINI_2_5_PRO' }, + { no: 331, name: 'MODEL_GOOGLE_GEMINI_2_5_PRO_EVAL' }, + { no: 327, name: 'MODEL_GOOGLE_GEMINI_FOR_GOOGLE_2_5_PRO' }, + { no: 328, name: 'MODEL_GOOGLE_GEMINI_NEMOSREEF' }, + { no: 332, name: 'MODEL_GOOGLE_GEMINI_2_5_FLASH_IMAGE_PREVIEW' }, + { no: 335, name: 'MODEL_GOOGLE_GEMINI_COMPUTER_USE_EXPERIMENTAL' }, + { no: 339, name: 'MODEL_GOOGLE_GEMINI_RAINSONG' }, + { no: 346, name: 'MODEL_GOOGLE_JARVIS_PROXY' }, + { no: 349, name: 'MODEL_GOOGLE_JARVIS_V4S' }, + { no: 323, name: 'MODEL_GOOGLE_GEMINI_TRAINING_POLICY' }, + { no: 326, name: 'MODEL_GOOGLE_GEMINI_INTERNAL_BYOM' }, + { no: 344, name: 'MODEL_GOOGLE_GEMINI_INTERNAL_TAB_FLASH_LITE' }, + { no: 345, name: 'MODEL_GOOGLE_GEMINI_INTERNAL_TAB_JUMP_FLASH_LITE' }, + { no: 336, name: 'MODEL_GOOGLE_GEMINI_HORIZONDAWN' }, + { no: 337, name: 'MODEL_GOOGLE_GEMINI_PUREPRISM' }, + { no: 338, name: 'MODEL_GOOGLE_GEMINI_GENTLEISLAND' }, + { no: 343, name: 'MODEL_GOOGLE_GEMINI_ORIONFIRE' }, + { no: 347, name: 'MODEL_GOOGLE_GEMINI_COSMICFORGE' }, + { no: 348, name: 'MODEL_GOOGLE_GEMINI_RIFTRUNNER' }, + { no: 352, name: 'MODEL_GOOGLE_GEMINI_RIFTRUNNER_THINKING_LOW' }, + { no: 353, name: 'MODEL_GOOGLE_GEMINI_RIFTRUNNER_THINKING_HIGH' }, + { no: 350, name: 'MODEL_GOOGLE_GEMINI_INFINITYJET' }, + { no: 351, name: 'MODEL_GOOGLE_GEMINI_INFINITYBLOOM' }, + { no: 281, name: 'MODEL_CLAUDE_4_SONNET' }, + { no: 282, name: 'MODEL_CLAUDE_4_SONNET_THINKING' }, + { no: 290, name: 'MODEL_CLAUDE_4_OPUS' }, + { no: 291, name: 'MODEL_CLAUDE_4_OPUS_THINKING' }, + { no: 333, name: 'MODEL_CLAUDE_4_5_SONNET' }, + { no: 334, name: 'MODEL_CLAUDE_4_5_SONNET_THINKING' }, + { no: 340, name: 'MODEL_CLAUDE_4_5_HAIKU' }, + { no: 341, name: 'MODEL_CLAUDE_4_5_HAIKU_THINKING' }, + { no: 342, name: 'MODEL_OPENAI_GPT_OSS_120B_MEDIUM' }, + { no: 1e3, name: 'MODEL_PLACEHOLDER_M0' }, + { no: 1001, name: 'MODEL_PLACEHOLDER_M1' }, + { no: 1002, name: 'MODEL_PLACEHOLDER_M2' }, + { no: 1003, name: 'MODEL_PLACEHOLDER_M3' }, + { no: 1004, name: 'MODEL_PLACEHOLDER_M4' }, + { no: 1005, name: 'MODEL_PLACEHOLDER_M5' }, + { no: 1006, name: 'MODEL_PLACEHOLDER_M6' }, + { no: 1007, name: 'MODEL_PLACEHOLDER_M7' }, + { no: 1008, name: 'MODEL_PLACEHOLDER_M8' }, + { no: 1009, name: 'MODEL_PLACEHOLDER_M9' }, + { no: 1010, name: 'MODEL_PLACEHOLDER_M10' }, + { no: 1011, name: 'MODEL_PLACEHOLDER_M11' }, + { no: 1012, name: 'MODEL_PLACEHOLDER_M12' }, + { no: 1013, name: 'MODEL_PLACEHOLDER_M13' }, + { no: 1014, name: 'MODEL_PLACEHOLDER_M14' }, + { no: 1015, name: 'MODEL_PLACEHOLDER_M15' }, + { no: 1016, name: 'MODEL_PLACEHOLDER_M16' }, + { no: 1017, name: 'MODEL_PLACEHOLDER_M17' }, + { no: 1018, name: 'MODEL_PLACEHOLDER_M18' }, + { no: 1019, name: 'MODEL_PLACEHOLDER_M19' }, + { no: 1020, name: 'MODEL_PLACEHOLDER_M20' }, + { no: 1021, name: 'MODEL_PLACEHOLDER_M21' }, + { no: 1022, name: 'MODEL_PLACEHOLDER_M22' }, + { no: 1023, name: 'MODEL_PLACEHOLDER_M23' }, + { no: 1024, name: 'MODEL_PLACEHOLDER_M24' }, + { no: 1025, name: 'MODEL_PLACEHOLDER_M25' }, + { no: 1026, name: 'MODEL_PLACEHOLDER_M26' }, + { no: 1027, name: 'MODEL_PLACEHOLDER_M27' }, + { no: 1028, name: 'MODEL_PLACEHOLDER_M28' }, + { no: 1029, name: 'MODEL_PLACEHOLDER_M29' }, + { no: 1030, name: 'MODEL_PLACEHOLDER_M30' }, + { no: 1031, name: 'MODEL_PLACEHOLDER_M31' }, + { no: 1032, name: 'MODEL_PLACEHOLDER_M32' }, + { no: 1033, name: 'MODEL_PLACEHOLDER_M33' }, + { no: 1034, name: 'MODEL_PLACEHOLDER_M34' }, + { no: 1035, name: 'MODEL_PLACEHOLDER_M35' }, + { no: 1036, name: 'MODEL_PLACEHOLDER_M36' }, + { no: 1037, name: 'MODEL_PLACEHOLDER_M37' }, + { no: 1038, name: 'MODEL_PLACEHOLDER_M38' }, + { no: 1039, name: 'MODEL_PLACEHOLDER_M39' }, + { no: 1040, name: 'MODEL_PLACEHOLDER_M40' }, + { no: 1041, name: 'MODEL_PLACEHOLDER_M41' }, + { no: 1042, name: 'MODEL_PLACEHOLDER_M42' }, + { no: 1043, name: 'MODEL_PLACEHOLDER_M43' }, + { no: 1044, name: 'MODEL_PLACEHOLDER_M44' }, + { no: 1045, name: 'MODEL_PLACEHOLDER_M45' }, + { no: 1046, name: 'MODEL_PLACEHOLDER_M46' }, + { no: 1047, name: 'MODEL_PLACEHOLDER_M47' }, + { no: 1048, name: 'MODEL_PLACEHOLDER_M48' }, + { no: 1049, name: 'MODEL_PLACEHOLDER_M49' }, + { no: 1050, name: 'MODEL_PLACEHOLDER_M50' }, +]); +var PromptElementExclusionReason; +(function (PromptElementExclusionReason2) { + PromptElementExclusionReason2[ + (PromptElementExclusionReason2['EXCLUSION_UNSPECIFIED'] = 0) + ] = 'EXCLUSION_UNSPECIFIED'; + PromptElementExclusionReason2[ + (PromptElementExclusionReason2['EXCLUSION_ELEMENT_KIND_DISABLED'] = 1) + ] = 'EXCLUSION_ELEMENT_KIND_DISABLED'; + PromptElementExclusionReason2[ + (PromptElementExclusionReason2['EXCLUSION_ELEMENT_MISSING_DEPENDENCY'] = 2) + ] = 'EXCLUSION_ELEMENT_MISSING_DEPENDENCY'; + PromptElementExclusionReason2[ + (PromptElementExclusionReason2['EXCLUSION_TOKEN_BUDGET'] = 3) + ] = 'EXCLUSION_TOKEN_BUDGET'; + PromptElementExclusionReason2[ + (PromptElementExclusionReason2['EXCLUSION_ACTIVE_SOURCE_OVERLAP'] = 4) + ] = 'EXCLUSION_ACTIVE_SOURCE_OVERLAP'; +})(PromptElementExclusionReason || (PromptElementExclusionReason = {})); +proto3.util.setEnumType( + PromptElementExclusionReason, + 'exa.codeium_common_pb.PromptElementExclusionReason', + [ + { no: 0, name: 'EXCLUSION_UNSPECIFIED' }, + { no: 1, name: 'EXCLUSION_ELEMENT_KIND_DISABLED' }, + { no: 2, name: 'EXCLUSION_ELEMENT_MISSING_DEPENDENCY' }, + { no: 3, name: 'EXCLUSION_TOKEN_BUDGET' }, + { no: 4, name: 'EXCLUSION_ACTIVE_SOURCE_OVERLAP' }, + ], +); +var StopReason; +(function (StopReason2) { + StopReason2[(StopReason2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + StopReason2[(StopReason2['INCOMPLETE'] = 1)] = 'INCOMPLETE'; + StopReason2[(StopReason2['STOP_PATTERN'] = 2)] = 'STOP_PATTERN'; + StopReason2[(StopReason2['MAX_TOKENS'] = 3)] = 'MAX_TOKENS'; + StopReason2[(StopReason2['FUNCTION_CALL'] = 10)] = 'FUNCTION_CALL'; + StopReason2[(StopReason2['CONTENT_FILTER'] = 11)] = 'CONTENT_FILTER'; + StopReason2[(StopReason2['NON_INSERTION'] = 12)] = 'NON_INSERTION'; + StopReason2[(StopReason2['ERROR'] = 13)] = 'ERROR'; + StopReason2[(StopReason2['IMPROPER_FORMAT'] = 14)] = 'IMPROPER_FORMAT'; + StopReason2[(StopReason2['OTHER'] = 15)] = 'OTHER'; + StopReason2[(StopReason2['CLIENT_CANCELED'] = 16)] = 'CLIENT_CANCELED'; + StopReason2[(StopReason2['CLIENT_TOOL_PARSE_ERROR'] = 17)] = + 'CLIENT_TOOL_PARSE_ERROR'; + StopReason2[(StopReason2['CLIENT_STREAM_ERROR'] = 18)] = + 'CLIENT_STREAM_ERROR'; + StopReason2[(StopReason2['CLIENT_LOOPING'] = 19)] = 'CLIENT_LOOPING'; + StopReason2[(StopReason2['CLIENT_INVALID_MESSAGE_ORDER'] = 20)] = + 'CLIENT_INVALID_MESSAGE_ORDER'; + StopReason2[(StopReason2['MIN_LOG_PROB'] = 4)] = 'MIN_LOG_PROB'; + StopReason2[(StopReason2['MAX_NEWLINES'] = 5)] = 'MAX_NEWLINES'; + StopReason2[(StopReason2['EXIT_SCOPE'] = 6)] = 'EXIT_SCOPE'; + StopReason2[(StopReason2['NONFINITE_LOGIT_OR_PROB'] = 7)] = + 'NONFINITE_LOGIT_OR_PROB'; + StopReason2[(StopReason2['FIRST_NON_WHITESPACE_LINE'] = 8)] = + 'FIRST_NON_WHITESPACE_LINE'; + StopReason2[(StopReason2['PARTIAL'] = 9)] = 'PARTIAL'; +})(StopReason || (StopReason = {})); +proto3.util.setEnumType(StopReason, 'exa.codeium_common_pb.StopReason', [ + { no: 0, name: 'STOP_REASON_UNSPECIFIED' }, + { no: 1, name: 'STOP_REASON_INCOMPLETE' }, + { no: 2, name: 'STOP_REASON_STOP_PATTERN' }, + { no: 3, name: 'STOP_REASON_MAX_TOKENS' }, + { no: 10, name: 'STOP_REASON_FUNCTION_CALL' }, + { no: 11, name: 'STOP_REASON_CONTENT_FILTER' }, + { no: 12, name: 'STOP_REASON_NON_INSERTION' }, + { no: 13, name: 'STOP_REASON_ERROR' }, + { no: 14, name: 'STOP_REASON_IMPROPER_FORMAT' }, + { no: 15, name: 'STOP_REASON_OTHER' }, + { no: 16, name: 'STOP_REASON_CLIENT_CANCELED' }, + { no: 17, name: 'STOP_REASON_CLIENT_TOOL_PARSE_ERROR' }, + { no: 18, name: 'STOP_REASON_CLIENT_STREAM_ERROR' }, + { no: 19, name: 'STOP_REASON_CLIENT_LOOPING' }, + { no: 20, name: 'STOP_REASON_CLIENT_INVALID_MESSAGE_ORDER' }, + { no: 4, name: 'STOP_REASON_MIN_LOG_PROB' }, + { no: 5, name: 'STOP_REASON_MAX_NEWLINES' }, + { no: 6, name: 'STOP_REASON_EXIT_SCOPE' }, + { no: 7, name: 'STOP_REASON_NONFINITE_LOGIT_OR_PROB' }, + { no: 8, name: 'STOP_REASON_FIRST_NON_WHITESPACE_LINE' }, + { no: 9, name: 'STOP_REASON_PARTIAL' }, +]); +var FilterReason; +(function (FilterReason2) { + FilterReason2[(FilterReason2['NONE'] = 0)] = 'NONE'; + FilterReason2[(FilterReason2['INCOMPLETE'] = 1)] = 'INCOMPLETE'; + FilterReason2[(FilterReason2['EMPTY'] = 2)] = 'EMPTY'; + FilterReason2[(FilterReason2['REPETITIVE'] = 3)] = 'REPETITIVE'; + FilterReason2[(FilterReason2['DUPLICATE'] = 4)] = 'DUPLICATE'; + FilterReason2[(FilterReason2['LONG_LINE'] = 5)] = 'LONG_LINE'; + FilterReason2[(FilterReason2['COMPLETIONS_CUTOFF'] = 6)] = + 'COMPLETIONS_CUTOFF'; + FilterReason2[(FilterReason2['ATTRIBUTION'] = 7)] = 'ATTRIBUTION'; + FilterReason2[(FilterReason2['NON_MATCHING'] = 8)] = 'NON_MATCHING'; + FilterReason2[(FilterReason2['NON_INSERTION'] = 9)] = 'NON_INSERTION'; +})(FilterReason || (FilterReason = {})); +proto3.util.setEnumType(FilterReason, 'exa.codeium_common_pb.FilterReason', [ + { no: 0, name: 'FILTER_REASON_NONE' }, + { no: 1, name: 'FILTER_REASON_INCOMPLETE' }, + { no: 2, name: 'FILTER_REASON_EMPTY' }, + { no: 3, name: 'FILTER_REASON_REPETITIVE' }, + { no: 4, name: 'FILTER_REASON_DUPLICATE' }, + { no: 5, name: 'FILTER_REASON_LONG_LINE' }, + { no: 6, name: 'FILTER_REASON_COMPLETIONS_CUTOFF' }, + { no: 7, name: 'FILTER_REASON_ATTRIBUTION' }, + { no: 8, name: 'FILTER_REASON_NON_MATCHING' }, + { no: 9, name: 'FILTER_REASON_NON_INSERTION' }, +]); +var AttributionStatus; +(function (AttributionStatus2) { + AttributionStatus2[(AttributionStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + AttributionStatus2[(AttributionStatus2['NEW_CODE'] = 1)] = 'NEW_CODE'; + AttributionStatus2[(AttributionStatus2['NO_LICENSE'] = 2)] = 'NO_LICENSE'; + AttributionStatus2[(AttributionStatus2['NONPERMISSIVE'] = 3)] = + 'NONPERMISSIVE'; + AttributionStatus2[(AttributionStatus2['PERMISSIVE'] = 4)] = 'PERMISSIVE'; + AttributionStatus2[(AttributionStatus2['PERMISSIVE_BLOCKED'] = 5)] = + 'PERMISSIVE_BLOCKED'; +})(AttributionStatus || (AttributionStatus = {})); +proto3.util.setEnumType( + AttributionStatus, + 'exa.codeium_common_pb.AttributionStatus', + [ + { no: 0, name: 'ATTRIBUTION_STATUS_UNSPECIFIED' }, + { no: 1, name: 'ATTRIBUTION_STATUS_NEW_CODE' }, + { no: 2, name: 'ATTRIBUTION_STATUS_NO_LICENSE' }, + { no: 3, name: 'ATTRIBUTION_STATUS_NONPERMISSIVE' }, + { no: 4, name: 'ATTRIBUTION_STATUS_PERMISSIVE' }, + { no: 5, name: 'ATTRIBUTION_STATUS_PERMISSIVE_BLOCKED' }, + ], +); +var EmbeddingPriority; +(function (EmbeddingPriority2) { + EmbeddingPriority2[(EmbeddingPriority2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + EmbeddingPriority2[(EmbeddingPriority2['HIGH'] = 1)] = 'HIGH'; + EmbeddingPriority2[(EmbeddingPriority2['LOW'] = 2)] = 'LOW'; +})(EmbeddingPriority || (EmbeddingPriority = {})); +proto3.util.setEnumType( + EmbeddingPriority, + 'exa.codeium_common_pb.EmbeddingPriority', + [ + { no: 0, name: 'EMBEDDING_PRIORITY_UNSPECIFIED' }, + { no: 1, name: 'EMBEDDING_PRIORITY_HIGH' }, + { no: 2, name: 'EMBEDDING_PRIORITY_LOW' }, + ], +); +var EmbeddingPrefix; +(function (EmbeddingPrefix2) { + EmbeddingPrefix2[(EmbeddingPrefix2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + EmbeddingPrefix2[(EmbeddingPrefix2['NOMIC_DOCUMENT'] = 1)] = 'NOMIC_DOCUMENT'; + EmbeddingPrefix2[(EmbeddingPrefix2['NOMIC_SEARCH'] = 2)] = 'NOMIC_SEARCH'; + EmbeddingPrefix2[(EmbeddingPrefix2['NOMIC_CLASSIFICATION'] = 3)] = + 'NOMIC_CLASSIFICATION'; + EmbeddingPrefix2[(EmbeddingPrefix2['NOMIC_CLUSTERING'] = 4)] = + 'NOMIC_CLUSTERING'; +})(EmbeddingPrefix || (EmbeddingPrefix = {})); +proto3.util.setEnumType( + EmbeddingPrefix, + 'exa.codeium_common_pb.EmbeddingPrefix', + [ + { no: 0, name: 'EMBEDDING_PREFIX_UNSPECIFIED' }, + { no: 1, name: 'EMBEDDING_PREFIX_NOMIC_DOCUMENT' }, + { no: 2, name: 'EMBEDDING_PREFIX_NOMIC_SEARCH' }, + { no: 3, name: 'EMBEDDING_PREFIX_NOMIC_CLASSIFICATION' }, + { no: 4, name: 'EMBEDDING_PREFIX_NOMIC_CLUSTERING' }, + ], +); +var EmbeddingSource; +(function (EmbeddingSource2) { + EmbeddingSource2[(EmbeddingSource2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + EmbeddingSource2[(EmbeddingSource2['CODE_CONTEXT_ITEM'] = 1)] = + 'CODE_CONTEXT_ITEM'; + EmbeddingSource2[(EmbeddingSource2['COMMIT_INTENT'] = 2)] = 'COMMIT_INTENT'; +})(EmbeddingSource || (EmbeddingSource = {})); +proto3.util.setEnumType( + EmbeddingSource, + 'exa.codeium_common_pb.EmbeddingSource', + [ + { no: 0, name: 'EMBEDDING_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'EMBEDDING_SOURCE_CODE_CONTEXT_ITEM' }, + { no: 2, name: 'EMBEDDING_SOURCE_COMMIT_INTENT' }, + ], +); +var EventType; +(function (EventType2) { + EventType2[(EventType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + EventType2[(EventType2['ENABLE_CODEIUM'] = 1)] = 'ENABLE_CODEIUM'; + EventType2[(EventType2['DISABLE_CODEIUM'] = 2)] = 'DISABLE_CODEIUM'; + EventType2[(EventType2['SHOW_PREVIOUS_COMPLETION'] = 3)] = + 'SHOW_PREVIOUS_COMPLETION'; + EventType2[(EventType2['SHOW_NEXT_COMPLETION'] = 4)] = 'SHOW_NEXT_COMPLETION'; + EventType2[(EventType2['COPILOT_STATUS'] = 5)] = 'COPILOT_STATUS'; + EventType2[(EventType2['COMPLETION_SUPPRESSED'] = 6)] = + 'COMPLETION_SUPPRESSED'; + EventType2[(EventType2['MEMORY_STATS'] = 8)] = 'MEMORY_STATS'; + EventType2[(EventType2['LOCAL_CONTEXT_RELEVANCE_CHECK'] = 9)] = + 'LOCAL_CONTEXT_RELEVANCE_CHECK'; + EventType2[(EventType2['ACTIVE_EDITOR_CHANGED'] = 10)] = + 'ACTIVE_EDITOR_CHANGED'; + EventType2[(EventType2['SHOW_PREVIOUS_CORTEX_STEP'] = 11)] = + 'SHOW_PREVIOUS_CORTEX_STEP'; + EventType2[(EventType2['SHOW_NEXT_CORTEX_STEP'] = 12)] = + 'SHOW_NEXT_CORTEX_STEP'; + EventType2[(EventType2['INDEXER_STATS'] = 13)] = 'INDEXER_STATS'; +})(EventType || (EventType = {})); +proto3.util.setEnumType(EventType, 'exa.codeium_common_pb.EventType', [ + { no: 0, name: 'EVENT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'EVENT_TYPE_ENABLE_CODEIUM' }, + { no: 2, name: 'EVENT_TYPE_DISABLE_CODEIUM' }, + { no: 3, name: 'EVENT_TYPE_SHOW_PREVIOUS_COMPLETION' }, + { no: 4, name: 'EVENT_TYPE_SHOW_NEXT_COMPLETION' }, + { no: 5, name: 'EVENT_TYPE_COPILOT_STATUS' }, + { no: 6, name: 'EVENT_TYPE_COMPLETION_SUPPRESSED' }, + { no: 8, name: 'EVENT_TYPE_MEMORY_STATS' }, + { no: 9, name: 'EVENT_TYPE_LOCAL_CONTEXT_RELEVANCE_CHECK' }, + { no: 10, name: 'EVENT_TYPE_ACTIVE_EDITOR_CHANGED' }, + { no: 11, name: 'EVENT_TYPE_SHOW_PREVIOUS_CORTEX_STEP' }, + { no: 12, name: 'EVENT_TYPE_SHOW_NEXT_CORTEX_STEP' }, + { no: 13, name: 'EVENT_TYPE_INDEXER_STATS' }, +]); +var SearchResultType; +(function (SearchResultType2) { + SearchResultType2[(SearchResultType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + SearchResultType2[(SearchResultType2['CLUSTER'] = 1)] = 'CLUSTER'; + SearchResultType2[(SearchResultType2['EXACT'] = 2)] = 'EXACT'; +})(SearchResultType || (SearchResultType = {})); +proto3.util.setEnumType( + SearchResultType, + 'exa.codeium_common_pb.SearchResultType', + [ + { no: 0, name: 'SEARCH_RESULT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'SEARCH_RESULT_TYPE_CLUSTER' }, + { no: 2, name: 'SEARCH_RESULT_TYPE_EXACT' }, + ], +); +var EmbedType; +(function (EmbedType2) { + EmbedType2[(EmbedType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + EmbedType2[(EmbedType2['RAW_SOURCE'] = 1)] = 'RAW_SOURCE'; + EmbedType2[(EmbedType2['DOCSTRING'] = 2)] = 'DOCSTRING'; + EmbedType2[(EmbedType2['FUNCTION'] = 3)] = 'FUNCTION'; + EmbedType2[(EmbedType2['NODEPATH'] = 4)] = 'NODEPATH'; + EmbedType2[(EmbedType2['DECLARATION'] = 5)] = 'DECLARATION'; + EmbedType2[(EmbedType2['NAIVE_CHUNK'] = 6)] = 'NAIVE_CHUNK'; + EmbedType2[(EmbedType2['SIGNATURE'] = 7)] = 'SIGNATURE'; +})(EmbedType || (EmbedType = {})); +proto3.util.setEnumType(EmbedType, 'exa.codeium_common_pb.EmbedType', [ + { no: 0, name: 'EMBED_TYPE_UNSPECIFIED' }, + { no: 1, name: 'EMBED_TYPE_RAW_SOURCE' }, + { no: 2, name: 'EMBED_TYPE_DOCSTRING' }, + { no: 3, name: 'EMBED_TYPE_FUNCTION' }, + { no: 4, name: 'EMBED_TYPE_NODEPATH' }, + { no: 5, name: 'EMBED_TYPE_DECLARATION' }, + { no: 6, name: 'EMBED_TYPE_NAIVE_CHUNK' }, + { no: 7, name: 'EMBED_TYPE_SIGNATURE' }, +]); +var CompletionSource; +(function (CompletionSource2) { + CompletionSource2[(CompletionSource2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CompletionSource2[(CompletionSource2['TYPING_AS_SUGGESTED'] = 1)] = + 'TYPING_AS_SUGGESTED'; + CompletionSource2[(CompletionSource2['CACHE'] = 2)] = 'CACHE'; + CompletionSource2[(CompletionSource2['NETWORK'] = 3)] = 'NETWORK'; +})(CompletionSource || (CompletionSource = {})); +proto3.util.setEnumType( + CompletionSource, + 'exa.codeium_common_pb.CompletionSource', + [ + { no: 0, name: 'COMPLETION_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'COMPLETION_SOURCE_TYPING_AS_SUGGESTED' }, + { no: 2, name: 'COMPLETION_SOURCE_CACHE' }, + { no: 3, name: 'COMPLETION_SOURCE_NETWORK' }, + ], +); +var CompletionType; +(function (CompletionType2) { + CompletionType2[(CompletionType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CompletionType2[(CompletionType2['SINGLE'] = 1)] = 'SINGLE'; + CompletionType2[(CompletionType2['MULTI'] = 2)] = 'MULTI'; + CompletionType2[(CompletionType2['INLINE_FIM'] = 3)] = 'INLINE_FIM'; + CompletionType2[(CompletionType2['CASCADE'] = 4)] = 'CASCADE'; +})(CompletionType || (CompletionType = {})); +proto3.util.setEnumType( + CompletionType, + 'exa.codeium_common_pb.CompletionType', + [ + { no: 0, name: 'COMPLETION_TYPE_UNSPECIFIED' }, + { no: 1, name: 'COMPLETION_TYPE_SINGLE' }, + { no: 2, name: 'COMPLETION_TYPE_MULTI' }, + { no: 3, name: 'COMPLETION_TYPE_INLINE_FIM' }, + { no: 4, name: 'COMPLETION_TYPE_CASCADE' }, + ], +); +var Language; +(function (Language2) { + Language2[(Language2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + Language2[(Language2['C'] = 1)] = 'C'; + Language2[(Language2['CLOJURE'] = 2)] = 'CLOJURE'; + Language2[(Language2['COFFEESCRIPT'] = 3)] = 'COFFEESCRIPT'; + Language2[(Language2['CPP'] = 4)] = 'CPP'; + Language2[(Language2['CSHARP'] = 5)] = 'CSHARP'; + Language2[(Language2['CSS'] = 6)] = 'CSS'; + Language2[(Language2['CUDACPP'] = 7)] = 'CUDACPP'; + Language2[(Language2['DOCKERFILE'] = 8)] = 'DOCKERFILE'; + Language2[(Language2['GO'] = 9)] = 'GO'; + Language2[(Language2['GROOVY'] = 10)] = 'GROOVY'; + Language2[(Language2['HANDLEBARS'] = 11)] = 'HANDLEBARS'; + Language2[(Language2['HASKELL'] = 12)] = 'HASKELL'; + Language2[(Language2['HCL'] = 13)] = 'HCL'; + Language2[(Language2['HTML'] = 14)] = 'HTML'; + Language2[(Language2['INI'] = 15)] = 'INI'; + Language2[(Language2['JAVA'] = 16)] = 'JAVA'; + Language2[(Language2['JAVASCRIPT'] = 17)] = 'JAVASCRIPT'; + Language2[(Language2['JSON'] = 18)] = 'JSON'; + Language2[(Language2['JULIA'] = 19)] = 'JULIA'; + Language2[(Language2['KOTLIN'] = 20)] = 'KOTLIN'; + Language2[(Language2['LATEX'] = 21)] = 'LATEX'; + Language2[(Language2['LESS'] = 22)] = 'LESS'; + Language2[(Language2['LUA'] = 23)] = 'LUA'; + Language2[(Language2['MAKEFILE'] = 24)] = 'MAKEFILE'; + Language2[(Language2['MARKDOWN'] = 25)] = 'MARKDOWN'; + Language2[(Language2['OBJECTIVEC'] = 26)] = 'OBJECTIVEC'; + Language2[(Language2['OBJECTIVECPP'] = 27)] = 'OBJECTIVECPP'; + Language2[(Language2['PERL'] = 28)] = 'PERL'; + Language2[(Language2['PHP'] = 29)] = 'PHP'; + Language2[(Language2['PLAINTEXT'] = 30)] = 'PLAINTEXT'; + Language2[(Language2['PROTOBUF'] = 31)] = 'PROTOBUF'; + Language2[(Language2['PBTXT'] = 32)] = 'PBTXT'; + Language2[(Language2['PYTHON'] = 33)] = 'PYTHON'; + Language2[(Language2['R'] = 34)] = 'R'; + Language2[(Language2['RUBY'] = 35)] = 'RUBY'; + Language2[(Language2['RUST'] = 36)] = 'RUST'; + Language2[(Language2['SASS'] = 37)] = 'SASS'; + Language2[(Language2['SCALA'] = 38)] = 'SCALA'; + Language2[(Language2['SCSS'] = 39)] = 'SCSS'; + Language2[(Language2['SHELL'] = 40)] = 'SHELL'; + Language2[(Language2['SQL'] = 41)] = 'SQL'; + Language2[(Language2['STARLARK'] = 42)] = 'STARLARK'; + Language2[(Language2['SWIFT'] = 43)] = 'SWIFT'; + Language2[(Language2['TSX'] = 44)] = 'TSX'; + Language2[(Language2['TYPESCRIPT'] = 45)] = 'TYPESCRIPT'; + Language2[(Language2['VISUALBASIC'] = 46)] = 'VISUALBASIC'; + Language2[(Language2['VUE'] = 47)] = 'VUE'; + Language2[(Language2['XML'] = 48)] = 'XML'; + Language2[(Language2['XSL'] = 49)] = 'XSL'; + Language2[(Language2['YAML'] = 50)] = 'YAML'; + Language2[(Language2['SVELTE'] = 51)] = 'SVELTE'; + Language2[(Language2['TOML'] = 52)] = 'TOML'; + Language2[(Language2['DART'] = 53)] = 'DART'; + Language2[(Language2['RST'] = 54)] = 'RST'; + Language2[(Language2['OCAML'] = 55)] = 'OCAML'; + Language2[(Language2['CMAKE'] = 56)] = 'CMAKE'; + Language2[(Language2['PASCAL'] = 57)] = 'PASCAL'; + Language2[(Language2['ELIXIR'] = 58)] = 'ELIXIR'; + Language2[(Language2['FSHARP'] = 59)] = 'FSHARP'; + Language2[(Language2['LISP'] = 60)] = 'LISP'; + Language2[(Language2['MATLAB'] = 61)] = 'MATLAB'; + Language2[(Language2['POWERSHELL'] = 62)] = 'POWERSHELL'; + Language2[(Language2['SOLIDITY'] = 63)] = 'SOLIDITY'; + Language2[(Language2['ADA'] = 64)] = 'ADA'; + Language2[(Language2['OCAML_INTERFACE'] = 65)] = 'OCAML_INTERFACE'; + Language2[(Language2['TREE_SITTER_QUERY'] = 66)] = 'TREE_SITTER_QUERY'; + Language2[(Language2['APL'] = 67)] = 'APL'; + Language2[(Language2['ASSEMBLY'] = 68)] = 'ASSEMBLY'; + Language2[(Language2['COBOL'] = 69)] = 'COBOL'; + Language2[(Language2['CRYSTAL'] = 70)] = 'CRYSTAL'; + Language2[(Language2['EMACS_LISP'] = 71)] = 'EMACS_LISP'; + Language2[(Language2['ERLANG'] = 72)] = 'ERLANG'; + Language2[(Language2['FORTRAN'] = 73)] = 'FORTRAN'; + Language2[(Language2['FREEFORM'] = 74)] = 'FREEFORM'; + Language2[(Language2['GRADLE'] = 75)] = 'GRADLE'; + Language2[(Language2['HACK'] = 76)] = 'HACK'; + Language2[(Language2['MAVEN'] = 77)] = 'MAVEN'; + Language2[(Language2['M68KASSEMBLY'] = 78)] = 'M68KASSEMBLY'; + Language2[(Language2['SAS'] = 79)] = 'SAS'; + Language2[(Language2['UNIXASSEMBLY'] = 80)] = 'UNIXASSEMBLY'; + Language2[(Language2['VBA'] = 81)] = 'VBA'; + Language2[(Language2['VIMSCRIPT'] = 82)] = 'VIMSCRIPT'; + Language2[(Language2['WEBASSEMBLY'] = 83)] = 'WEBASSEMBLY'; + Language2[(Language2['BLADE'] = 84)] = 'BLADE'; + Language2[(Language2['ASTRO'] = 85)] = 'ASTRO'; + Language2[(Language2['MUMPS'] = 86)] = 'MUMPS'; + Language2[(Language2['GDSCRIPT'] = 87)] = 'GDSCRIPT'; + Language2[(Language2['NIM'] = 88)] = 'NIM'; + Language2[(Language2['PROLOG'] = 89)] = 'PROLOG'; + Language2[(Language2['MARKDOWN_INLINE'] = 90)] = 'MARKDOWN_INLINE'; + Language2[(Language2['APEX'] = 91)] = 'APEX'; +})(Language || (Language = {})); +proto3.util.setEnumType(Language, 'exa.codeium_common_pb.Language', [ + { no: 0, name: 'LANGUAGE_UNSPECIFIED' }, + { no: 1, name: 'LANGUAGE_C' }, + { no: 2, name: 'LANGUAGE_CLOJURE' }, + { no: 3, name: 'LANGUAGE_COFFEESCRIPT' }, + { no: 4, name: 'LANGUAGE_CPP' }, + { no: 5, name: 'LANGUAGE_CSHARP' }, + { no: 6, name: 'LANGUAGE_CSS' }, + { no: 7, name: 'LANGUAGE_CUDACPP' }, + { no: 8, name: 'LANGUAGE_DOCKERFILE' }, + { no: 9, name: 'LANGUAGE_GO' }, + { no: 10, name: 'LANGUAGE_GROOVY' }, + { no: 11, name: 'LANGUAGE_HANDLEBARS' }, + { no: 12, name: 'LANGUAGE_HASKELL' }, + { no: 13, name: 'LANGUAGE_HCL' }, + { no: 14, name: 'LANGUAGE_HTML' }, + { no: 15, name: 'LANGUAGE_INI' }, + { no: 16, name: 'LANGUAGE_JAVA' }, + { no: 17, name: 'LANGUAGE_JAVASCRIPT' }, + { no: 18, name: 'LANGUAGE_JSON' }, + { no: 19, name: 'LANGUAGE_JULIA' }, + { no: 20, name: 'LANGUAGE_KOTLIN' }, + { no: 21, name: 'LANGUAGE_LATEX' }, + { no: 22, name: 'LANGUAGE_LESS' }, + { no: 23, name: 'LANGUAGE_LUA' }, + { no: 24, name: 'LANGUAGE_MAKEFILE' }, + { no: 25, name: 'LANGUAGE_MARKDOWN' }, + { no: 26, name: 'LANGUAGE_OBJECTIVEC' }, + { no: 27, name: 'LANGUAGE_OBJECTIVECPP' }, + { no: 28, name: 'LANGUAGE_PERL' }, + { no: 29, name: 'LANGUAGE_PHP' }, + { no: 30, name: 'LANGUAGE_PLAINTEXT' }, + { no: 31, name: 'LANGUAGE_PROTOBUF' }, + { no: 32, name: 'LANGUAGE_PBTXT' }, + { no: 33, name: 'LANGUAGE_PYTHON' }, + { no: 34, name: 'LANGUAGE_R' }, + { no: 35, name: 'LANGUAGE_RUBY' }, + { no: 36, name: 'LANGUAGE_RUST' }, + { no: 37, name: 'LANGUAGE_SASS' }, + { no: 38, name: 'LANGUAGE_SCALA' }, + { no: 39, name: 'LANGUAGE_SCSS' }, + { no: 40, name: 'LANGUAGE_SHELL' }, + { no: 41, name: 'LANGUAGE_SQL' }, + { no: 42, name: 'LANGUAGE_STARLARK' }, + { no: 43, name: 'LANGUAGE_SWIFT' }, + { no: 44, name: 'LANGUAGE_TSX' }, + { no: 45, name: 'LANGUAGE_TYPESCRIPT' }, + { no: 46, name: 'LANGUAGE_VISUALBASIC' }, + { no: 47, name: 'LANGUAGE_VUE' }, + { no: 48, name: 'LANGUAGE_XML' }, + { no: 49, name: 'LANGUAGE_XSL' }, + { no: 50, name: 'LANGUAGE_YAML' }, + { no: 51, name: 'LANGUAGE_SVELTE' }, + { no: 52, name: 'LANGUAGE_TOML' }, + { no: 53, name: 'LANGUAGE_DART' }, + { no: 54, name: 'LANGUAGE_RST' }, + { no: 55, name: 'LANGUAGE_OCAML' }, + { no: 56, name: 'LANGUAGE_CMAKE' }, + { no: 57, name: 'LANGUAGE_PASCAL' }, + { no: 58, name: 'LANGUAGE_ELIXIR' }, + { no: 59, name: 'LANGUAGE_FSHARP' }, + { no: 60, name: 'LANGUAGE_LISP' }, + { no: 61, name: 'LANGUAGE_MATLAB' }, + { no: 62, name: 'LANGUAGE_POWERSHELL' }, + { no: 63, name: 'LANGUAGE_SOLIDITY' }, + { no: 64, name: 'LANGUAGE_ADA' }, + { no: 65, name: 'LANGUAGE_OCAML_INTERFACE' }, + { no: 66, name: 'LANGUAGE_TREE_SITTER_QUERY' }, + { no: 67, name: 'LANGUAGE_APL' }, + { no: 68, name: 'LANGUAGE_ASSEMBLY' }, + { no: 69, name: 'LANGUAGE_COBOL' }, + { no: 70, name: 'LANGUAGE_CRYSTAL' }, + { no: 71, name: 'LANGUAGE_EMACS_LISP' }, + { no: 72, name: 'LANGUAGE_ERLANG' }, + { no: 73, name: 'LANGUAGE_FORTRAN' }, + { no: 74, name: 'LANGUAGE_FREEFORM' }, + { no: 75, name: 'LANGUAGE_GRADLE' }, + { no: 76, name: 'LANGUAGE_HACK' }, + { no: 77, name: 'LANGUAGE_MAVEN' }, + { no: 78, name: 'LANGUAGE_M68KASSEMBLY' }, + { no: 79, name: 'LANGUAGE_SAS' }, + { no: 80, name: 'LANGUAGE_UNIXASSEMBLY' }, + { no: 81, name: 'LANGUAGE_VBA' }, + { no: 82, name: 'LANGUAGE_VIMSCRIPT' }, + { no: 83, name: 'LANGUAGE_WEBASSEMBLY' }, + { no: 84, name: 'LANGUAGE_BLADE' }, + { no: 85, name: 'LANGUAGE_ASTRO' }, + { no: 86, name: 'LANGUAGE_MUMPS' }, + { no: 87, name: 'LANGUAGE_GDSCRIPT' }, + { no: 88, name: 'LANGUAGE_NIM' }, + { no: 89, name: 'LANGUAGE_PROLOG' }, + { no: 90, name: 'LANGUAGE_MARKDOWN_INLINE' }, + { no: 91, name: 'LANGUAGE_APEX' }, +]); +var ChatMessageSource; +(function (ChatMessageSource2) { + ChatMessageSource2[(ChatMessageSource2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ChatMessageSource2[(ChatMessageSource2['USER'] = 1)] = 'USER'; + ChatMessageSource2[(ChatMessageSource2['SYSTEM'] = 2)] = 'SYSTEM'; + ChatMessageSource2[(ChatMessageSource2['UNKNOWN'] = 3)] = 'UNKNOWN'; + ChatMessageSource2[(ChatMessageSource2['TOOL'] = 4)] = 'TOOL'; + ChatMessageSource2[(ChatMessageSource2['SYSTEM_PROMPT'] = 5)] = + 'SYSTEM_PROMPT'; +})(ChatMessageSource || (ChatMessageSource = {})); +proto3.util.setEnumType( + ChatMessageSource, + 'exa.codeium_common_pb.ChatMessageSource', + [ + { no: 0, name: 'CHAT_MESSAGE_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'CHAT_MESSAGE_SOURCE_USER' }, + { no: 2, name: 'CHAT_MESSAGE_SOURCE_SYSTEM' }, + { no: 3, name: 'CHAT_MESSAGE_SOURCE_UNKNOWN' }, + { no: 4, name: 'CHAT_MESSAGE_SOURCE_TOOL' }, + { no: 5, name: 'CHAT_MESSAGE_SOURCE_SYSTEM_PROMPT' }, + ], +); +var UserTeamStatus; +(function (UserTeamStatus2) { + UserTeamStatus2[(UserTeamStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + UserTeamStatus2[(UserTeamStatus2['PENDING'] = 1)] = 'PENDING'; + UserTeamStatus2[(UserTeamStatus2['APPROVED'] = 2)] = 'APPROVED'; + UserTeamStatus2[(UserTeamStatus2['REJECTED'] = 3)] = 'REJECTED'; +})(UserTeamStatus || (UserTeamStatus = {})); +proto3.util.setEnumType( + UserTeamStatus, + 'exa.codeium_common_pb.UserTeamStatus', + [ + { no: 0, name: 'USER_TEAM_STATUS_UNSPECIFIED' }, + { no: 1, name: 'USER_TEAM_STATUS_PENDING' }, + { no: 2, name: 'USER_TEAM_STATUS_APPROVED' }, + { no: 3, name: 'USER_TEAM_STATUS_REJECTED' }, + ], +); +var TeamsFeatures; +(function (TeamsFeatures2) { + TeamsFeatures2[(TeamsFeatures2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + TeamsFeatures2[(TeamsFeatures2['SSO'] = 1)] = 'SSO'; + TeamsFeatures2[(TeamsFeatures2['ATTRIBUTION'] = 2)] = 'ATTRIBUTION'; + TeamsFeatures2[(TeamsFeatures2['PHI'] = 3)] = 'PHI'; + TeamsFeatures2[(TeamsFeatures2['CORTEX'] = 4)] = 'CORTEX'; + TeamsFeatures2[(TeamsFeatures2['OPENAI_DISABLED'] = 5)] = 'OPENAI_DISABLED'; + TeamsFeatures2[(TeamsFeatures2['REMOTE_INDEXING_DISABLED'] = 6)] = + 'REMOTE_INDEXING_DISABLED'; + TeamsFeatures2[(TeamsFeatures2['API_KEY_ENABLED'] = 7)] = 'API_KEY_ENABLED'; +})(TeamsFeatures || (TeamsFeatures = {})); +proto3.util.setEnumType(TeamsFeatures, 'exa.codeium_common_pb.TeamsFeatures', [ + { no: 0, name: 'TEAMS_FEATURES_UNSPECIFIED' }, + { no: 1, name: 'TEAMS_FEATURES_SSO' }, + { no: 2, name: 'TEAMS_FEATURES_ATTRIBUTION' }, + { no: 3, name: 'TEAMS_FEATURES_PHI' }, + { no: 4, name: 'TEAMS_FEATURES_CORTEX' }, + { no: 5, name: 'TEAMS_FEATURES_OPENAI_DISABLED' }, + { no: 6, name: 'TEAMS_FEATURES_REMOTE_INDEXING_DISABLED' }, + { no: 7, name: 'TEAMS_FEATURES_API_KEY_ENABLED' }, +]); +var UserFeatures; +(function (UserFeatures2) { + UserFeatures2[(UserFeatures2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + UserFeatures2[(UserFeatures2['CORTEX'] = 1)] = 'CORTEX'; + UserFeatures2[(UserFeatures2['CORTEX_TEST'] = 2)] = 'CORTEX_TEST'; +})(UserFeatures || (UserFeatures = {})); +proto3.util.setEnumType(UserFeatures, 'exa.codeium_common_pb.UserFeatures', [ + { no: 0, name: 'USER_FEATURES_UNSPECIFIED' }, + { no: 1, name: 'USER_FEATURES_CORTEX' }, + { no: 2, name: 'USER_FEATURES_CORTEX_TEST' }, +]); +var Permission; +(function (Permission2) { + Permission2[(Permission2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + Permission2[(Permission2['ATTRIBUTION_READ'] = 1)] = 'ATTRIBUTION_READ'; + Permission2[(Permission2['ANALYTICS_READ'] = 2)] = 'ANALYTICS_READ'; + Permission2[(Permission2['LICENSE_READ'] = 3)] = 'LICENSE_READ'; + Permission2[(Permission2['TEAM_USER_READ'] = 4)] = 'TEAM_USER_READ'; + Permission2[(Permission2['TEAM_USER_UPDATE'] = 5)] = 'TEAM_USER_UPDATE'; + Permission2[(Permission2['TEAM_USER_DELETE'] = 6)] = 'TEAM_USER_DELETE'; + Permission2[(Permission2['TEAM_USER_INVITE'] = 17)] = 'TEAM_USER_INVITE'; + Permission2[(Permission2['INDEXING_READ'] = 7)] = 'INDEXING_READ'; + Permission2[(Permission2['INDEXING_CREATE'] = 8)] = 'INDEXING_CREATE'; + Permission2[(Permission2['INDEXING_UPDATE'] = 9)] = 'INDEXING_UPDATE'; + Permission2[(Permission2['INDEXING_DELETE'] = 10)] = 'INDEXING_DELETE'; + Permission2[(Permission2['INDEXING_MANAGEMENT'] = 27)] = + 'INDEXING_MANAGEMENT'; + Permission2[(Permission2['FINETUNING_READ'] = 19)] = 'FINETUNING_READ'; + Permission2[(Permission2['FINETUNING_CREATE'] = 20)] = 'FINETUNING_CREATE'; + Permission2[(Permission2['FINETUNING_UPDATE'] = 21)] = 'FINETUNING_UPDATE'; + Permission2[(Permission2['FINETUNING_DELETE'] = 22)] = 'FINETUNING_DELETE'; + Permission2[(Permission2['SSO_READ'] = 11)] = 'SSO_READ'; + Permission2[(Permission2['SSO_WRITE'] = 12)] = 'SSO_WRITE'; + Permission2[(Permission2['SERVICE_KEY_READ'] = 13)] = 'SERVICE_KEY_READ'; + Permission2[(Permission2['SERVICE_KEY_CREATE'] = 14)] = 'SERVICE_KEY_CREATE'; + Permission2[(Permission2['SERVICE_KEY_UPDATE'] = 28)] = 'SERVICE_KEY_UPDATE'; + Permission2[(Permission2['SERVICE_KEY_DELETE'] = 15)] = 'SERVICE_KEY_DELETE'; + Permission2[(Permission2['ROLE_READ'] = 23)] = 'ROLE_READ'; + Permission2[(Permission2['ROLE_CREATE'] = 24)] = 'ROLE_CREATE'; + Permission2[(Permission2['ROLE_UPDATE'] = 25)] = 'ROLE_UPDATE'; + Permission2[(Permission2['ROLE_DELETE'] = 26)] = 'ROLE_DELETE'; + Permission2[(Permission2['BILLING_READ'] = 16)] = 'BILLING_READ'; + Permission2[(Permission2['BILLING_WRITE'] = 18)] = 'BILLING_WRITE'; + Permission2[(Permission2['EXTERNAL_CHAT_UPDATE'] = 29)] = + 'EXTERNAL_CHAT_UPDATE'; + Permission2[(Permission2['TEAM_SETTINGS_READ'] = 30)] = 'TEAM_SETTINGS_READ'; + Permission2[(Permission2['TEAM_SETTINGS_UPDATE'] = 31)] = + 'TEAM_SETTINGS_UPDATE'; +})(Permission || (Permission = {})); +proto3.util.setEnumType(Permission, 'exa.codeium_common_pb.Permission', [ + { no: 0, name: 'PERMISSION_UNSPECIFIED' }, + { no: 1, name: 'PERMISSION_ATTRIBUTION_READ' }, + { no: 2, name: 'PERMISSION_ANALYTICS_READ' }, + { no: 3, name: 'PERMISSION_LICENSE_READ' }, + { no: 4, name: 'PERMISSION_TEAM_USER_READ' }, + { no: 5, name: 'PERMISSION_TEAM_USER_UPDATE' }, + { no: 6, name: 'PERMISSION_TEAM_USER_DELETE' }, + { no: 17, name: 'PERMISSION_TEAM_USER_INVITE' }, + { no: 7, name: 'PERMISSION_INDEXING_READ' }, + { no: 8, name: 'PERMISSION_INDEXING_CREATE' }, + { no: 9, name: 'PERMISSION_INDEXING_UPDATE' }, + { no: 10, name: 'PERMISSION_INDEXING_DELETE' }, + { no: 27, name: 'PERMISSION_INDEXING_MANAGEMENT' }, + { no: 19, name: 'PERMISSION_FINETUNING_READ' }, + { no: 20, name: 'PERMISSION_FINETUNING_CREATE' }, + { no: 21, name: 'PERMISSION_FINETUNING_UPDATE' }, + { no: 22, name: 'PERMISSION_FINETUNING_DELETE' }, + { no: 11, name: 'PERMISSION_SSO_READ' }, + { no: 12, name: 'PERMISSION_SSO_WRITE' }, + { no: 13, name: 'PERMISSION_SERVICE_KEY_READ' }, + { no: 14, name: 'PERMISSION_SERVICE_KEY_CREATE' }, + { no: 28, name: 'PERMISSION_SERVICE_KEY_UPDATE' }, + { no: 15, name: 'PERMISSION_SERVICE_KEY_DELETE' }, + { no: 23, name: 'PERMISSION_ROLE_READ' }, + { no: 24, name: 'PERMISSION_ROLE_CREATE' }, + { no: 25, name: 'PERMISSION_ROLE_UPDATE' }, + { no: 26, name: 'PERMISSION_ROLE_DELETE' }, + { no: 16, name: 'PERMISSION_BILLING_READ' }, + { no: 18, name: 'PERMISSION_BILLING_WRITE' }, + { no: 29, name: 'PERMISSION_EXTERNAL_CHAT_UPDATE' }, + { no: 30, name: 'PERMISSION_TEAM_SETTINGS_READ' }, + { no: 31, name: 'PERMISSION_TEAM_SETTINGS_UPDATE' }, +]); +var TeamsTier; +(function (TeamsTier2) { + TeamsTier2[(TeamsTier2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + TeamsTier2[(TeamsTier2['TEAMS'] = 1)] = 'TEAMS'; + TeamsTier2[(TeamsTier2['PRO'] = 2)] = 'PRO'; + TeamsTier2[(TeamsTier2['TRIAL'] = 9)] = 'TRIAL'; + TeamsTier2[(TeamsTier2['ENTERPRISE_SAAS'] = 3)] = 'ENTERPRISE_SAAS'; + TeamsTier2[(TeamsTier2['HYBRID'] = 4)] = 'HYBRID'; + TeamsTier2[(TeamsTier2['ENTERPRISE_SELF_HOSTED'] = 5)] = + 'ENTERPRISE_SELF_HOSTED'; + TeamsTier2[(TeamsTier2['ENTERPRISE_SELF_SERVE'] = 10)] = + 'ENTERPRISE_SELF_SERVE'; + TeamsTier2[(TeamsTier2['WAITLIST_PRO'] = 6)] = 'WAITLIST_PRO'; + TeamsTier2[(TeamsTier2['TEAMS_ULTIMATE'] = 7)] = 'TEAMS_ULTIMATE'; + TeamsTier2[(TeamsTier2['PRO_ULTIMATE'] = 8)] = 'PRO_ULTIMATE'; +})(TeamsTier || (TeamsTier = {})); +proto3.util.setEnumType(TeamsTier, 'exa.codeium_common_pb.TeamsTier', [ + { no: 0, name: 'TEAMS_TIER_UNSPECIFIED' }, + { no: 1, name: 'TEAMS_TIER_TEAMS' }, + { no: 2, name: 'TEAMS_TIER_PRO' }, + { no: 9, name: 'TEAMS_TIER_TRIAL' }, + { no: 3, name: 'TEAMS_TIER_ENTERPRISE_SAAS' }, + { no: 4, name: 'TEAMS_TIER_HYBRID' }, + { no: 5, name: 'TEAMS_TIER_ENTERPRISE_SELF_HOSTED' }, + { no: 10, name: 'TEAMS_TIER_ENTERPRISE_SELF_SERVE' }, + { no: 6, name: 'TEAMS_TIER_WAITLIST_PRO' }, + { no: 7, name: 'TEAMS_TIER_TEAMS_ULTIMATE' }, + { no: 8, name: 'TEAMS_TIER_PRO_ULTIMATE' }, +]); +var ModelProvider; +(function (ModelProvider2) { + ModelProvider2[(ModelProvider2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ModelProvider2[(ModelProvider2['ANTIGRAVITY'] = 1)] = 'ANTIGRAVITY'; + ModelProvider2[(ModelProvider2['OPENAI'] = 2)] = 'OPENAI'; + ModelProvider2[(ModelProvider2['ANTHROPIC'] = 3)] = 'ANTHROPIC'; + ModelProvider2[(ModelProvider2['GOOGLE'] = 4)] = 'GOOGLE'; + ModelProvider2[(ModelProvider2['XAI'] = 5)] = 'XAI'; + ModelProvider2[(ModelProvider2['DEEPSEEK'] = 6)] = 'DEEPSEEK'; +})(ModelProvider || (ModelProvider = {})); +proto3.util.setEnumType(ModelProvider, 'exa.codeium_common_pb.ModelProvider', [ + { no: 0, name: 'MODEL_PROVIDER_UNSPECIFIED' }, + { no: 1, name: 'MODEL_PROVIDER_ANTIGRAVITY' }, + { no: 2, name: 'MODEL_PROVIDER_OPENAI' }, + { no: 3, name: 'MODEL_PROVIDER_ANTHROPIC' }, + { no: 4, name: 'MODEL_PROVIDER_GOOGLE' }, + { no: 5, name: 'MODEL_PROVIDER_XAI' }, + { no: 6, name: 'MODEL_PROVIDER_DEEPSEEK' }, +]); +var ModelPricingType; +(function (ModelPricingType2) { + ModelPricingType2[(ModelPricingType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ModelPricingType2[(ModelPricingType2['STATIC_CREDIT'] = 1)] = 'STATIC_CREDIT'; + ModelPricingType2[(ModelPricingType2['API'] = 2)] = 'API'; + ModelPricingType2[(ModelPricingType2['BYOK'] = 3)] = 'BYOK'; +})(ModelPricingType || (ModelPricingType = {})); +proto3.util.setEnumType( + ModelPricingType, + 'exa.codeium_common_pb.ModelPricingType', + [ + { no: 0, name: 'MODEL_PRICING_TYPE_UNSPECIFIED' }, + { no: 1, name: 'MODEL_PRICING_TYPE_STATIC_CREDIT' }, + { no: 2, name: 'MODEL_PRICING_TYPE_API' }, + { no: 3, name: 'MODEL_PRICING_TYPE_BYOK' }, + ], +); +var TransactionStatus; +(function (TransactionStatus2) { + TransactionStatus2[(TransactionStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + TransactionStatus2[(TransactionStatus2['SUCCEEDED'] = 1)] = 'SUCCEEDED'; + TransactionStatus2[(TransactionStatus2['PROCESSING'] = 2)] = 'PROCESSING'; + TransactionStatus2[(TransactionStatus2['FAILED'] = 3)] = 'FAILED'; + TransactionStatus2[(TransactionStatus2['NO_ACTIVE'] = 4)] = 'NO_ACTIVE'; +})(TransactionStatus || (TransactionStatus = {})); +proto3.util.setEnumType( + TransactionStatus, + 'exa.codeium_common_pb.TransactionStatus', + [ + { no: 0, name: 'TRANSACTION_STATUS_UNSPECIFIED' }, + { no: 1, name: 'TRANSACTION_STATUS_SUCCEEDED' }, + { no: 2, name: 'TRANSACTION_STATUS_PROCESSING' }, + { no: 3, name: 'TRANSACTION_STATUS_FAILED' }, + { no: 4, name: 'TRANSACTION_STATUS_NO_ACTIVE' }, + ], +); +var ScmProvider; +(function (ScmProvider2) { + ScmProvider2[(ScmProvider2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ScmProvider2[(ScmProvider2['GITHUB'] = 1)] = 'GITHUB'; + ScmProvider2[(ScmProvider2['GITLAB'] = 2)] = 'GITLAB'; + ScmProvider2[(ScmProvider2['BITBUCKET'] = 3)] = 'BITBUCKET'; + ScmProvider2[(ScmProvider2['AZURE_DEVOPS'] = 4)] = 'AZURE_DEVOPS'; +})(ScmProvider || (ScmProvider = {})); +proto3.util.setEnumType(ScmProvider, 'exa.codeium_common_pb.ScmProvider', [ + { no: 0, name: 'SCM_PROVIDER_UNSPECIFIED' }, + { no: 1, name: 'SCM_PROVIDER_GITHUB' }, + { no: 2, name: 'SCM_PROVIDER_GITLAB' }, + { no: 3, name: 'SCM_PROVIDER_BITBUCKET' }, + { no: 4, name: 'SCM_PROVIDER_AZURE_DEVOPS' }, +]); +var ScmType; +(function (ScmType2) { + ScmType2[(ScmType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ScmType2[(ScmType2['GIT'] = 1)] = 'GIT'; + ScmType2[(ScmType2['PERFORCE'] = 2)] = 'PERFORCE'; +})(ScmType || (ScmType = {})); +proto3.util.setEnumType(ScmType, 'exa.codeium_common_pb.ScmType', [ + { no: 0, name: 'SCM_TYPE_UNSPECIFIED' }, + { no: 1, name: 'SCM_TYPE_GIT' }, + { no: 2, name: 'SCM_TYPE_PERFORCE' }, +]); +var CodeContextType; +(function (CodeContextType2) { + CodeContextType2[(CodeContextType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CodeContextType2[(CodeContextType2['FUNCTION'] = 1)] = 'FUNCTION'; + CodeContextType2[(CodeContextType2['CLASS'] = 2)] = 'CLASS'; + CodeContextType2[(CodeContextType2['IMPORT'] = 3)] = 'IMPORT'; + CodeContextType2[(CodeContextType2['NAIVE_LINECHUNK'] = 4)] = + 'NAIVE_LINECHUNK'; + CodeContextType2[(CodeContextType2['REFERENCE_FUNCTION'] = 5)] = + 'REFERENCE_FUNCTION'; + CodeContextType2[(CodeContextType2['REFERENCE_CLASS'] = 6)] = + 'REFERENCE_CLASS'; + CodeContextType2[(CodeContextType2['FILE'] = 7)] = 'FILE'; + CodeContextType2[(CodeContextType2['TERMINAL'] = 8)] = 'TERMINAL'; +})(CodeContextType || (CodeContextType = {})); +proto3.util.setEnumType( + CodeContextType, + 'exa.codeium_common_pb.CodeContextType', + [ + { no: 0, name: 'CODE_CONTEXT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CODE_CONTEXT_TYPE_FUNCTION' }, + { no: 2, name: 'CODE_CONTEXT_TYPE_CLASS' }, + { no: 3, name: 'CODE_CONTEXT_TYPE_IMPORT' }, + { no: 4, name: 'CODE_CONTEXT_TYPE_NAIVE_LINECHUNK' }, + { no: 5, name: 'CODE_CONTEXT_TYPE_REFERENCE_FUNCTION' }, + { no: 6, name: 'CODE_CONTEXT_TYPE_REFERENCE_CLASS' }, + { no: 7, name: 'CODE_CONTEXT_TYPE_FILE' }, + { no: 8, name: 'CODE_CONTEXT_TYPE_TERMINAL' }, + ], +); +var CodeContextSource; +(function (CodeContextSource2) { + CodeContextSource2[(CodeContextSource2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CodeContextSource2[(CodeContextSource2['OPEN_DOCS'] = 1)] = 'OPEN_DOCS'; + CodeContextSource2[(CodeContextSource2['SEARCH_RESULT'] = 2)] = + 'SEARCH_RESULT'; + CodeContextSource2[(CodeContextSource2['IMPORT'] = 3)] = 'IMPORT'; + CodeContextSource2[(CodeContextSource2['LOCAL_DIRECTORY'] = 4)] = + 'LOCAL_DIRECTORY'; + CodeContextSource2[(CodeContextSource2['LAST_ACTIVE_DOC'] = 5)] = + 'LAST_ACTIVE_DOC'; + CodeContextSource2[(CodeContextSource2['ORACLE_ITEMS'] = 6)] = 'ORACLE_ITEMS'; + CodeContextSource2[(CodeContextSource2['PINNED_CONTEXT'] = 7)] = + 'PINNED_CONTEXT'; + CodeContextSource2[(CodeContextSource2['RESEARCH_STATE'] = 8)] = + 'RESEARCH_STATE'; + CodeContextSource2[(CodeContextSource2['GROUND_TRUTH_PLAN_EDIT'] = 9)] = + 'GROUND_TRUTH_PLAN_EDIT'; + CodeContextSource2[(CodeContextSource2['COMMIT_GRAPH'] = 10)] = + 'COMMIT_GRAPH'; +})(CodeContextSource || (CodeContextSource = {})); +proto3.util.setEnumType( + CodeContextSource, + 'exa.codeium_common_pb.CodeContextSource', + [ + { no: 0, name: 'CODE_CONTEXT_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'CODE_CONTEXT_SOURCE_OPEN_DOCS' }, + { no: 2, name: 'CODE_CONTEXT_SOURCE_SEARCH_RESULT' }, + { no: 3, name: 'CODE_CONTEXT_SOURCE_IMPORT' }, + { no: 4, name: 'CODE_CONTEXT_SOURCE_LOCAL_DIRECTORY' }, + { no: 5, name: 'CODE_CONTEXT_SOURCE_LAST_ACTIVE_DOC' }, + { no: 6, name: 'CODE_CONTEXT_SOURCE_ORACLE_ITEMS' }, + { no: 7, name: 'CODE_CONTEXT_SOURCE_PINNED_CONTEXT' }, + { no: 8, name: 'CODE_CONTEXT_SOURCE_RESEARCH_STATE' }, + { no: 9, name: 'CODE_CONTEXT_SOURCE_GROUND_TRUTH_PLAN_EDIT' }, + { no: 10, name: 'CODE_CONTEXT_SOURCE_COMMIT_GRAPH' }, + ], +); +var ContextSnippetType; +(function (ContextSnippetType2) { + ContextSnippetType2[(ContextSnippetType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ContextSnippetType2[(ContextSnippetType2['RAW_SOURCE'] = 1)] = 'RAW_SOURCE'; + ContextSnippetType2[(ContextSnippetType2['SIGNATURE'] = 2)] = 'SIGNATURE'; + ContextSnippetType2[(ContextSnippetType2['NODEPATH'] = 3)] = 'NODEPATH'; +})(ContextSnippetType || (ContextSnippetType = {})); +proto3.util.setEnumType( + ContextSnippetType, + 'exa.codeium_common_pb.ContextSnippetType', + [ + { no: 0, name: 'CONTEXT_SNIPPET_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CONTEXT_SNIPPET_TYPE_RAW_SOURCE' }, + { no: 2, name: 'CONTEXT_SNIPPET_TYPE_SIGNATURE' }, + { no: 3, name: 'CONTEXT_SNIPPET_TYPE_NODEPATH' }, + ], +); +var CommitIntentType; +(function (CommitIntentType2) { + CommitIntentType2[(CommitIntentType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CommitIntentType2[(CommitIntentType2['COMMIT_MESSAGE'] = 1)] = + 'COMMIT_MESSAGE'; +})(CommitIntentType || (CommitIntentType = {})); +proto3.util.setEnumType( + CommitIntentType, + 'exa.codeium_common_pb.CommitIntentType', + [ + { no: 0, name: 'COMMIT_INTENT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'COMMIT_INTENT_TYPE_COMMIT_MESSAGE' }, + ], +); +var GpuType; +(function (GpuType2) { + GpuType2[(GpuType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + GpuType2[(GpuType2['L4'] = 1)] = 'L4'; + GpuType2[(GpuType2['T4'] = 2)] = 'T4'; + GpuType2[(GpuType2['A10'] = 3)] = 'A10'; + GpuType2[(GpuType2['A100'] = 4)] = 'A100'; + GpuType2[(GpuType2['V100'] = 5)] = 'V100'; + GpuType2[(GpuType2['A5000'] = 6)] = 'A5000'; +})(GpuType || (GpuType = {})); +proto3.util.setEnumType(GpuType, 'exa.codeium_common_pb.GpuType', [ + { no: 0, name: 'GPU_TYPE_UNSPECIFIED' }, + { no: 1, name: 'GPU_TYPE_L4' }, + { no: 2, name: 'GPU_TYPE_T4' }, + { no: 3, name: 'GPU_TYPE_A10' }, + { no: 4, name: 'GPU_TYPE_A100' }, + { no: 5, name: 'GPU_TYPE_V100' }, + { no: 6, name: 'GPU_TYPE_A5000' }, +]); +var ContextInclusionType; +(function (ContextInclusionType2) { + ContextInclusionType2[(ContextInclusionType2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + ContextInclusionType2[(ContextInclusionType2['INCLUDE'] = 1)] = 'INCLUDE'; + ContextInclusionType2[(ContextInclusionType2['EXCLUDE'] = 2)] = 'EXCLUDE'; +})(ContextInclusionType || (ContextInclusionType = {})); +proto3.util.setEnumType( + ContextInclusionType, + 'exa.codeium_common_pb.ContextInclusionType', + [ + { no: 0, name: 'CONTEXT_INCLUSION_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CONTEXT_INCLUSION_TYPE_INCLUDE' }, + { no: 2, name: 'CONTEXT_INCLUSION_TYPE_EXCLUDE' }, + ], +); +var ThemePreference; +(function (ThemePreference2) { + ThemePreference2[(ThemePreference2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ThemePreference2[(ThemePreference2['AUTO'] = 1)] = 'AUTO'; + ThemePreference2[(ThemePreference2['LIGHT'] = 2)] = 'LIGHT'; + ThemePreference2[(ThemePreference2['DARK'] = 3)] = 'DARK'; +})(ThemePreference || (ThemePreference = {})); +proto3.util.setEnumType( + ThemePreference, + 'exa.codeium_common_pb.ThemePreference', + [ + { no: 0, name: 'THEME_PREFERENCE_UNSPECIFIED' }, + { no: 1, name: 'THEME_PREFERENCE_AUTO' }, + { no: 2, name: 'THEME_PREFERENCE_LIGHT' }, + { no: 3, name: 'THEME_PREFERENCE_DARK' }, + ], +); +var AutocompleteSpeed; +(function (AutocompleteSpeed2) { + AutocompleteSpeed2[(AutocompleteSpeed2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + AutocompleteSpeed2[(AutocompleteSpeed2['SLOW'] = 1)] = 'SLOW'; + AutocompleteSpeed2[(AutocompleteSpeed2['DEFAULT'] = 2)] = 'DEFAULT'; + AutocompleteSpeed2[(AutocompleteSpeed2['FAST'] = 3)] = 'FAST'; +})(AutocompleteSpeed || (AutocompleteSpeed = {})); +proto3.util.setEnumType( + AutocompleteSpeed, + 'exa.codeium_common_pb.AutocompleteSpeed', + [ + { no: 0, name: 'AUTOCOMPLETE_SPEED_UNSPECIFIED' }, + { no: 1, name: 'AUTOCOMPLETE_SPEED_SLOW' }, + { no: 2, name: 'AUTOCOMPLETE_SPEED_DEFAULT' }, + { no: 3, name: 'AUTOCOMPLETE_SPEED_FAST' }, + ], +); +var TabEnabled; +(function (TabEnabled2) { + TabEnabled2[(TabEnabled2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + TabEnabled2[(TabEnabled2['OFF'] = 1)] = 'OFF'; + TabEnabled2[(TabEnabled2['ON'] = 2)] = 'ON'; +})(TabEnabled || (TabEnabled = {})); +proto3.util.setEnumType(TabEnabled, 'exa.codeium_common_pb.TabEnabled', [ + { no: 0, name: 'TAB_ENABLED_UNSPECIFIED' }, + { no: 1, name: 'TAB_ENABLED_OFF' }, + { no: 2, name: 'TAB_ENABLED_ON' }, +]); +var CascadeCommandsAutoExecution; +(function (CascadeCommandsAutoExecution2) { + CascadeCommandsAutoExecution2[ + (CascadeCommandsAutoExecution2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + CascadeCommandsAutoExecution2[(CascadeCommandsAutoExecution2['OFF'] = 1)] = + 'OFF'; + CascadeCommandsAutoExecution2[(CascadeCommandsAutoExecution2['AUTO'] = 2)] = + 'AUTO'; + CascadeCommandsAutoExecution2[(CascadeCommandsAutoExecution2['EAGER'] = 3)] = + 'EAGER'; +})(CascadeCommandsAutoExecution || (CascadeCommandsAutoExecution = {})); +proto3.util.setEnumType( + CascadeCommandsAutoExecution, + 'exa.codeium_common_pb.CascadeCommandsAutoExecution', + [ + { no: 0, name: 'CASCADE_COMMANDS_AUTO_EXECUTION_UNSPECIFIED' }, + { no: 1, name: 'CASCADE_COMMANDS_AUTO_EXECUTION_OFF' }, + { no: 2, name: 'CASCADE_COMMANDS_AUTO_EXECUTION_AUTO' }, + { no: 3, name: 'CASCADE_COMMANDS_AUTO_EXECUTION_EAGER' }, + ], +); +var ArtifactReviewMode; +(function (ArtifactReviewMode2) { + ArtifactReviewMode2[(ArtifactReviewMode2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ArtifactReviewMode2[(ArtifactReviewMode2['ALWAYS'] = 1)] = 'ALWAYS'; + ArtifactReviewMode2[(ArtifactReviewMode2['TURBO'] = 2)] = 'TURBO'; + ArtifactReviewMode2[(ArtifactReviewMode2['AUTO'] = 3)] = 'AUTO'; +})(ArtifactReviewMode || (ArtifactReviewMode = {})); +proto3.util.setEnumType( + ArtifactReviewMode, + 'exa.codeium_common_pb.ArtifactReviewMode', + [ + { no: 0, name: 'ARTIFACT_REVIEW_MODE_UNSPECIFIED' }, + { no: 1, name: 'ARTIFACT_REVIEW_MODE_ALWAYS' }, + { no: 2, name: 'ARTIFACT_REVIEW_MODE_TURBO' }, + { no: 3, name: 'ARTIFACT_REVIEW_MODE_AUTO' }, + ], +); +var ExtensionPanelTab; +(function (ExtensionPanelTab2) { + ExtensionPanelTab2[(ExtensionPanelTab2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ExtensionPanelTab2[(ExtensionPanelTab2['CHAT'] = 1)] = 'CHAT'; + ExtensionPanelTab2[(ExtensionPanelTab2['PROFILE'] = 2)] = 'PROFILE'; + ExtensionPanelTab2[(ExtensionPanelTab2['BRAIN'] = 4)] = 'BRAIN'; + ExtensionPanelTab2[(ExtensionPanelTab2['COMMAND'] = 5)] = 'COMMAND'; + ExtensionPanelTab2[(ExtensionPanelTab2['CORTEX'] = 6)] = 'CORTEX'; + ExtensionPanelTab2[(ExtensionPanelTab2['DEBUG'] = 7)] = 'DEBUG'; +})(ExtensionPanelTab || (ExtensionPanelTab = {})); +proto3.util.setEnumType( + ExtensionPanelTab, + 'exa.codeium_common_pb.ExtensionPanelTab', + [ + { no: 0, name: 'EXTENSION_PANEL_TAB_UNSPECIFIED' }, + { no: 1, name: 'EXTENSION_PANEL_TAB_CHAT' }, + { no: 2, name: 'EXTENSION_PANEL_TAB_PROFILE' }, + { no: 4, name: 'EXTENSION_PANEL_TAB_BRAIN' }, + { no: 5, name: 'EXTENSION_PANEL_TAB_COMMAND' }, + { no: 6, name: 'EXTENSION_PANEL_TAB_CORTEX' }, + { no: 7, name: 'EXTENSION_PANEL_TAB_DEBUG' }, + ], +); +var RememberLastModelSelection; +(function (RememberLastModelSelection2) { + RememberLastModelSelection2[ + (RememberLastModelSelection2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + RememberLastModelSelection2[(RememberLastModelSelection2['ENABLED'] = 1)] = + 'ENABLED'; + RememberLastModelSelection2[(RememberLastModelSelection2['DISABLED'] = 2)] = + 'DISABLED'; +})(RememberLastModelSelection || (RememberLastModelSelection = {})); +proto3.util.setEnumType( + RememberLastModelSelection, + 'exa.codeium_common_pb.RememberLastModelSelection', + [ + { no: 0, name: 'REMEMBER_LAST_MODEL_SELECTION_UNSPECIFIED' }, + { no: 1, name: 'REMEMBER_LAST_MODEL_SELECTION_ENABLED' }, + { no: 2, name: 'REMEMBER_LAST_MODEL_SELECTION_DISABLED' }, + ], +); +var CascadeNUXEvent; +(function (CascadeNUXEvent2) { + CascadeNUXEvent2[(CascadeNUXEvent2['CASCADE_NUX_EVENT_UNSPECIFIED'] = 0)] = + 'CASCADE_NUX_EVENT_UNSPECIFIED'; + CascadeNUXEvent2[(CascadeNUXEvent2['CASCADE_NUX_EVENT_DIFF_OVERVIEW'] = 1)] = + 'CASCADE_NUX_EVENT_DIFF_OVERVIEW'; + CascadeNUXEvent2[(CascadeNUXEvent2['CASCADE_NUX_EVENT_WEB_SEARCH'] = 2)] = + 'CASCADE_NUX_EVENT_WEB_SEARCH'; + CascadeNUXEvent2[ + (CascadeNUXEvent2['CASCADE_NUX_EVENT_NEW_MODELS_WAVE2'] = 3) + ] = 'CASCADE_NUX_EVENT_NEW_MODELS_WAVE2'; + CascadeNUXEvent2[(CascadeNUXEvent2['CASCADE_NUX_EVENT_TOOL_CALL'] = 4)] = + 'CASCADE_NUX_EVENT_TOOL_CALL'; + CascadeNUXEvent2[ + (CascadeNUXEvent2['CASCADE_NUX_EVENT_MODEL_SELECTOR_NUX'] = 5) + ] = 'CASCADE_NUX_EVENT_MODEL_SELECTOR_NUX'; + CascadeNUXEvent2[ + (CascadeNUXEvent2['CASCADE_NUX_EVENT_TOOL_CALL_PRICING_NUX'] = 6) + ] = 'CASCADE_NUX_EVENT_TOOL_CALL_PRICING_NUX'; + CascadeNUXEvent2[ + (CascadeNUXEvent2['CASCADE_NUX_EVENT_WRITE_CHAT_MODE'] = 7) + ] = 'CASCADE_NUX_EVENT_WRITE_CHAT_MODE'; + CascadeNUXEvent2[(CascadeNUXEvent2['CASCADE_NUX_EVENT_REVERT_STEP'] = 8)] = + 'CASCADE_NUX_EVENT_REVERT_STEP'; + CascadeNUXEvent2[(CascadeNUXEvent2['CASCADE_NUX_EVENT_RULES'] = 9)] = + 'CASCADE_NUX_EVENT_RULES'; + CascadeNUXEvent2[(CascadeNUXEvent2['CASCADE_NUX_EVENT_WEB_MENTION'] = 10)] = + 'CASCADE_NUX_EVENT_WEB_MENTION'; + CascadeNUXEvent2[ + (CascadeNUXEvent2['CASCADE_NUX_EVENT_BACKGROUND_CASCADE'] = 11) + ] = 'CASCADE_NUX_EVENT_BACKGROUND_CASCADE'; + CascadeNUXEvent2[ + (CascadeNUXEvent2['CASCADE_NUX_EVENT_ANTHROPIC_API_PRICING'] = 12) + ] = 'CASCADE_NUX_EVENT_ANTHROPIC_API_PRICING'; + CascadeNUXEvent2[(CascadeNUXEvent2['CASCADE_NUX_EVENT_PLAN_MODE'] = 13)] = + 'CASCADE_NUX_EVENT_PLAN_MODE'; + CascadeNUXEvent2[ + (CascadeNUXEvent2['CASCADE_NUX_EVENT_OPEN_BROWSER_URL'] = 14) + ] = 'CASCADE_NUX_EVENT_OPEN_BROWSER_URL'; +})(CascadeNUXEvent || (CascadeNUXEvent = {})); +proto3.util.setEnumType( + CascadeNUXEvent, + 'exa.codeium_common_pb.CascadeNUXEvent', + [ + { no: 0, name: 'CASCADE_NUX_EVENT_UNSPECIFIED' }, + { no: 1, name: 'CASCADE_NUX_EVENT_DIFF_OVERVIEW' }, + { no: 2, name: 'CASCADE_NUX_EVENT_WEB_SEARCH' }, + { no: 3, name: 'CASCADE_NUX_EVENT_NEW_MODELS_WAVE2' }, + { no: 4, name: 'CASCADE_NUX_EVENT_TOOL_CALL' }, + { no: 5, name: 'CASCADE_NUX_EVENT_MODEL_SELECTOR_NUX' }, + { no: 6, name: 'CASCADE_NUX_EVENT_TOOL_CALL_PRICING_NUX' }, + { no: 7, name: 'CASCADE_NUX_EVENT_WRITE_CHAT_MODE' }, + { no: 8, name: 'CASCADE_NUX_EVENT_REVERT_STEP' }, + { no: 9, name: 'CASCADE_NUX_EVENT_RULES' }, + { no: 10, name: 'CASCADE_NUX_EVENT_WEB_MENTION' }, + { no: 11, name: 'CASCADE_NUX_EVENT_BACKGROUND_CASCADE' }, + { no: 12, name: 'CASCADE_NUX_EVENT_ANTHROPIC_API_PRICING' }, + { no: 13, name: 'CASCADE_NUX_EVENT_PLAN_MODE' }, + { no: 14, name: 'CASCADE_NUX_EVENT_OPEN_BROWSER_URL' }, + ], +); +var UserNUXEvent; +(function (UserNUXEvent2) { + UserNUXEvent2[(UserNUXEvent2['USER_NUX_EVENT_UNSPECIFIED'] = 0)] = + 'USER_NUX_EVENT_UNSPECIFIED'; + UserNUXEvent2[ + (UserNUXEvent2['USER_NUX_EVENT_DISMISS_ANTIGRAVITY_CROSS_SELL'] = 1) + ] = 'USER_NUX_EVENT_DISMISS_ANTIGRAVITY_CROSS_SELL'; +})(UserNUXEvent || (UserNUXEvent = {})); +proto3.util.setEnumType(UserNUXEvent, 'exa.codeium_common_pb.UserNUXEvent', [ + { no: 0, name: 'USER_NUX_EVENT_UNSPECIFIED' }, + { no: 1, name: 'USER_NUX_EVENT_DISMISS_ANTIGRAVITY_CROSS_SELL' }, +]); +var ConversationalPlannerMode; +(function (ConversationalPlannerMode2) { + ConversationalPlannerMode2[(ConversationalPlannerMode2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + ConversationalPlannerMode2[(ConversationalPlannerMode2['DEFAULT'] = 1)] = + 'DEFAULT'; + ConversationalPlannerMode2[(ConversationalPlannerMode2['READ_ONLY'] = 2)] = + 'READ_ONLY'; +})(ConversationalPlannerMode || (ConversationalPlannerMode = {})); +proto3.util.setEnumType( + ConversationalPlannerMode, + 'exa.codeium_common_pb.ConversationalPlannerMode', + [ + { no: 0, name: 'CONVERSATIONAL_PLANNER_MODE_UNSPECIFIED' }, + { no: 1, name: 'CONVERSATIONAL_PLANNER_MODE_DEFAULT' }, + { no: 2, name: 'CONVERSATIONAL_PLANNER_MODE_READ_ONLY' }, + ], +); +var PlanningMode; +(function (PlanningMode2) { + PlanningMode2[(PlanningMode2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + PlanningMode2[(PlanningMode2['OFF'] = 1)] = 'OFF'; + PlanningMode2[(PlanningMode2['ON'] = 2)] = 'ON'; +})(PlanningMode || (PlanningMode = {})); +proto3.util.setEnumType(PlanningMode, 'exa.codeium_common_pb.PlanningMode', [ + { no: 0, name: 'PLANNING_MODE_UNSPECIFIED' }, + { no: 1, name: 'PLANNING_MODE_OFF' }, + { no: 2, name: 'PLANNING_MODE_ON' }, +]); +var TabToJump; +(function (TabToJump2) { + TabToJump2[(TabToJump2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + TabToJump2[(TabToJump2['ENABLED'] = 1)] = 'ENABLED'; + TabToJump2[(TabToJump2['DISABLED'] = 2)] = 'DISABLED'; +})(TabToJump || (TabToJump = {})); +proto3.util.setEnumType(TabToJump, 'exa.codeium_common_pb.TabToJump', [ + { no: 0, name: 'TAB_TO_JUMP_UNSPECIFIED' }, + { no: 1, name: 'TAB_TO_JUMP_ENABLED' }, + { no: 2, name: 'TAB_TO_JUMP_DISABLED' }, +]); +var CascadeWebSearchTool; +(function (CascadeWebSearchTool2) { + CascadeWebSearchTool2[(CascadeWebSearchTool2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CascadeWebSearchTool2[(CascadeWebSearchTool2['ENABLED'] = 1)] = 'ENABLED'; + CascadeWebSearchTool2[(CascadeWebSearchTool2['DISABLED'] = 2)] = 'DISABLED'; +})(CascadeWebSearchTool || (CascadeWebSearchTool = {})); +proto3.util.setEnumType( + CascadeWebSearchTool, + 'exa.codeium_common_pb.CascadeWebSearchTool', + [ + { no: 0, name: 'CASCADE_WEB_SEARCH_TOOL_UNSPECIFIED' }, + { no: 1, name: 'CASCADE_WEB_SEARCH_TOOL_ENABLED' }, + { no: 2, name: 'CASCADE_WEB_SEARCH_TOOL_DISABLED' }, + ], +); +var CascadeRunExtensionCode; +(function (CascadeRunExtensionCode2) { + CascadeRunExtensionCode2[(CascadeRunExtensionCode2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CascadeRunExtensionCode2[(CascadeRunExtensionCode2['ENABLED'] = 1)] = + 'ENABLED'; + CascadeRunExtensionCode2[(CascadeRunExtensionCode2['DISABLED'] = 2)] = + 'DISABLED'; + CascadeRunExtensionCode2[(CascadeRunExtensionCode2['ONLY'] = 3)] = 'ONLY'; +})(CascadeRunExtensionCode || (CascadeRunExtensionCode = {})); +proto3.util.setEnumType( + CascadeRunExtensionCode, + 'exa.codeium_common_pb.CascadeRunExtensionCode', + [ + { no: 0, name: 'CASCADE_RUN_EXTENSION_CODE_UNSPECIFIED' }, + { no: 1, name: 'CASCADE_RUN_EXTENSION_CODE_ENABLED' }, + { no: 2, name: 'CASCADE_RUN_EXTENSION_CODE_DISABLED' }, + { no: 3, name: 'CASCADE_RUN_EXTENSION_CODE_ONLY' }, + ], +); +var CascadeInputAutocomplete; +(function (CascadeInputAutocomplete2) { + CascadeInputAutocomplete2[(CascadeInputAutocomplete2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CascadeInputAutocomplete2[(CascadeInputAutocomplete2['ENABLED'] = 1)] = + 'ENABLED'; + CascadeInputAutocomplete2[(CascadeInputAutocomplete2['DISABLED'] = 2)] = + 'DISABLED'; +})(CascadeInputAutocomplete || (CascadeInputAutocomplete = {})); +proto3.util.setEnumType( + CascadeInputAutocomplete, + 'exa.codeium_common_pb.CascadeInputAutocomplete', + [ + { no: 0, name: 'CASCADE_INPUT_AUTOCOMPLETE_UNSPECIFIED' }, + { no: 1, name: 'CASCADE_INPUT_AUTOCOMPLETE_ENABLED' }, + { no: 2, name: 'CASCADE_INPUT_AUTOCOMPLETE_DISABLED' }, + ], +); +var CascadeRunExtensionCodeAutoRun; +(function (CascadeRunExtensionCodeAutoRun2) { + CascadeRunExtensionCodeAutoRun2[ + (CascadeRunExtensionCodeAutoRun2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + CascadeRunExtensionCodeAutoRun2[ + (CascadeRunExtensionCodeAutoRun2['ENABLED'] = 1) + ] = 'ENABLED'; + CascadeRunExtensionCodeAutoRun2[ + (CascadeRunExtensionCodeAutoRun2['DISABLED'] = 2) + ] = 'DISABLED'; + CascadeRunExtensionCodeAutoRun2[ + (CascadeRunExtensionCodeAutoRun2['MODEL_DECIDES'] = 3) + ] = 'MODEL_DECIDES'; +})(CascadeRunExtensionCodeAutoRun || (CascadeRunExtensionCodeAutoRun = {})); +proto3.util.setEnumType( + CascadeRunExtensionCodeAutoRun, + 'exa.codeium_common_pb.CascadeRunExtensionCodeAutoRun', + [ + { no: 0, name: 'CASCADE_RUN_EXTENSION_CODE_AUTO_RUN_UNSPECIFIED' }, + { no: 1, name: 'CASCADE_RUN_EXTENSION_CODE_AUTO_RUN_ENABLED' }, + { no: 2, name: 'CASCADE_RUN_EXTENSION_CODE_AUTO_RUN_DISABLED' }, + { no: 3, name: 'CASCADE_RUN_EXTENSION_CODE_AUTO_RUN_MODEL_DECIDES' }, + ], +); +var AgentBrowserTools; +(function (AgentBrowserTools2) { + AgentBrowserTools2[(AgentBrowserTools2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + AgentBrowserTools2[(AgentBrowserTools2['ENABLED'] = 1)] = 'ENABLED'; + AgentBrowserTools2[(AgentBrowserTools2['DISABLED'] = 2)] = 'DISABLED'; +})(AgentBrowserTools || (AgentBrowserTools = {})); +proto3.util.setEnumType( + AgentBrowserTools, + 'exa.codeium_common_pb.AgentBrowserTools', + [ + { no: 0, name: 'AGENT_BROWSER_TOOLS_UNSPECIFIED' }, + { no: 1, name: 'AGENT_BROWSER_TOOLS_ENABLED' }, + { no: 2, name: 'AGENT_BROWSER_TOOLS_DISABLED' }, + ], +); +var FeatureUsageType; +(function (FeatureUsageType2) { + FeatureUsageType2[(FeatureUsageType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + FeatureUsageType2[(FeatureUsageType2['CASCADE_BROWSER'] = 1)] = + 'CASCADE_BROWSER'; + FeatureUsageType2[(FeatureUsageType2['CASCADE_WEB_AT_MENTION'] = 2)] = + 'CASCADE_WEB_AT_MENTION'; + FeatureUsageType2[(FeatureUsageType2['CASCADE_REVERT_TO_STEP'] = 3)] = + 'CASCADE_REVERT_TO_STEP'; + FeatureUsageType2[(FeatureUsageType2['CASCADE_CLICK_MODEL_SELECTOR'] = 4)] = + 'CASCADE_CLICK_MODEL_SELECTOR'; + FeatureUsageType2[(FeatureUsageType2['CASCADE_MESSAGE_FEEDBACK'] = 5)] = + 'CASCADE_MESSAGE_FEEDBACK'; +})(FeatureUsageType || (FeatureUsageType = {})); +proto3.util.setEnumType( + FeatureUsageType, + 'exa.codeium_common_pb.FeatureUsageType', + [ + { no: 0, name: 'FEATURE_USAGE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'FEATURE_USAGE_TYPE_CASCADE_BROWSER' }, + { no: 2, name: 'FEATURE_USAGE_TYPE_CASCADE_WEB_AT_MENTION' }, + { no: 3, name: 'FEATURE_USAGE_TYPE_CASCADE_REVERT_TO_STEP' }, + { no: 4, name: 'FEATURE_USAGE_TYPE_CASCADE_CLICK_MODEL_SELECTOR' }, + { no: 5, name: 'FEATURE_USAGE_TYPE_CASCADE_MESSAGE_FEEDBACK' }, + ], +); +var PlanMode; +(function (PlanMode2) { + PlanMode2[(PlanMode2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + PlanMode2[(PlanMode2['ON'] = 1)] = 'ON'; + PlanMode2[(PlanMode2['OFF'] = 2)] = 'OFF'; +})(PlanMode || (PlanMode = {})); +proto3.util.setEnumType(PlanMode, 'exa.codeium_common_pb.PlanMode', [ + { no: 0, name: 'PLAN_MODE_UNSPECIFIED' }, + { no: 1, name: 'PLAN_MODE_ON' }, + { no: 2, name: 'PLAN_MODE_OFF' }, +]); +var AutoContinueOnMaxGeneratorInvocations; +(function (AutoContinueOnMaxGeneratorInvocations2) { + AutoContinueOnMaxGeneratorInvocations2[ + (AutoContinueOnMaxGeneratorInvocations2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + AutoContinueOnMaxGeneratorInvocations2[ + (AutoContinueOnMaxGeneratorInvocations2['ENABLED'] = 1) + ] = 'ENABLED'; + AutoContinueOnMaxGeneratorInvocations2[ + (AutoContinueOnMaxGeneratorInvocations2['DISABLED'] = 2) + ] = 'DISABLED'; +})( + AutoContinueOnMaxGeneratorInvocations || + (AutoContinueOnMaxGeneratorInvocations = {}), +); +proto3.util.setEnumType( + AutoContinueOnMaxGeneratorInvocations, + 'exa.codeium_common_pb.AutoContinueOnMaxGeneratorInvocations', + [ + { no: 0, name: 'AUTO_CONTINUE_ON_MAX_GENERATOR_INVOCATIONS_UNSPECIFIED' }, + { no: 1, name: 'AUTO_CONTINUE_ON_MAX_GENERATOR_INVOCATIONS_ENABLED' }, + { no: 2, name: 'AUTO_CONTINUE_ON_MAX_GENERATOR_INVOCATIONS_DISABLED' }, + ], +); +var CascadeNUXLocation; +(function (CascadeNUXLocation2) { + CascadeNUXLocation2[ + (CascadeNUXLocation2['CASCADE_NUX_LOCATION_UNSPECIFIED'] = 0) + ] = 'CASCADE_NUX_LOCATION_UNSPECIFIED'; + CascadeNUXLocation2[ + (CascadeNUXLocation2['CASCADE_NUX_LOCATION_CASCADE_INPUT'] = 1) + ] = 'CASCADE_NUX_LOCATION_CASCADE_INPUT'; + CascadeNUXLocation2[ + (CascadeNUXLocation2['CASCADE_NUX_LOCATION_MODEL_SELECTOR'] = 2) + ] = 'CASCADE_NUX_LOCATION_MODEL_SELECTOR'; + CascadeNUXLocation2[ + (CascadeNUXLocation2['CASCADE_NUX_LOCATION_RULES_TAB'] = 4) + ] = 'CASCADE_NUX_LOCATION_RULES_TAB'; + CascadeNUXLocation2[ + (CascadeNUXLocation2['CASCADE_NUX_LOCATION_REVERT_STEP'] = 6) + ] = 'CASCADE_NUX_LOCATION_REVERT_STEP'; + CascadeNUXLocation2[ + (CascadeNUXLocation2['CASCADE_NUX_LOCATION_PLAN_MODE'] = 7) + ] = 'CASCADE_NUX_LOCATION_PLAN_MODE'; + CascadeNUXLocation2[ + (CascadeNUXLocation2['CASCADE_NUX_LOCATION_WRITE_CHAT_MODE'] = 8) + ] = 'CASCADE_NUX_LOCATION_WRITE_CHAT_MODE'; + CascadeNUXLocation2[ + (CascadeNUXLocation2['CASCADE_NUX_LOCATION_TOOLBAR'] = 9) + ] = 'CASCADE_NUX_LOCATION_TOOLBAR'; + CascadeNUXLocation2[ + (CascadeNUXLocation2['CASCADE_NUX_LOCATION_MANAGER_BOTTOM_LEFT'] = 10) + ] = 'CASCADE_NUX_LOCATION_MANAGER_BOTTOM_LEFT'; + CascadeNUXLocation2[ + (CascadeNUXLocation2['CASCADE_NUX_LOCATION_ARTIFACT_VIEW_BOTTOM_LEFT'] = 11) + ] = 'CASCADE_NUX_LOCATION_ARTIFACT_VIEW_BOTTOM_LEFT'; +})(CascadeNUXLocation || (CascadeNUXLocation = {})); +proto3.util.setEnumType( + CascadeNUXLocation, + 'exa.codeium_common_pb.CascadeNUXLocation', + [ + { no: 0, name: 'CASCADE_NUX_LOCATION_UNSPECIFIED' }, + { no: 1, name: 'CASCADE_NUX_LOCATION_CASCADE_INPUT' }, + { no: 2, name: 'CASCADE_NUX_LOCATION_MODEL_SELECTOR' }, + { no: 4, name: 'CASCADE_NUX_LOCATION_RULES_TAB' }, + { no: 6, name: 'CASCADE_NUX_LOCATION_REVERT_STEP' }, + { no: 7, name: 'CASCADE_NUX_LOCATION_PLAN_MODE' }, + { no: 8, name: 'CASCADE_NUX_LOCATION_WRITE_CHAT_MODE' }, + { no: 9, name: 'CASCADE_NUX_LOCATION_TOOLBAR' }, + { no: 10, name: 'CASCADE_NUX_LOCATION_MANAGER_BOTTOM_LEFT' }, + { no: 11, name: 'CASCADE_NUX_LOCATION_ARTIFACT_VIEW_BOTTOM_LEFT' }, + ], +); +var CascadeNUXIcon; +(function (CascadeNUXIcon2) { + CascadeNUXIcon2[(CascadeNUXIcon2['CASCADE_NUX_ICON_UNSPECIFIED'] = 0)] = + 'CASCADE_NUX_ICON_UNSPECIFIED'; + CascadeNUXIcon2[(CascadeNUXIcon2['CASCADE_NUX_ICON_WEB_SEARCH'] = 1)] = + 'CASCADE_NUX_ICON_WEB_SEARCH'; + CascadeNUXIcon2[ + (CascadeNUXIcon2['CASCADE_NUX_ICON_ANTIGRAVITY_BROWSER'] = 2) + ] = 'CASCADE_NUX_ICON_ANTIGRAVITY_BROWSER'; +})(CascadeNUXIcon || (CascadeNUXIcon = {})); +proto3.util.setEnumType( + CascadeNUXIcon, + 'exa.codeium_common_pb.CascadeNUXIcon', + [ + { no: 0, name: 'CASCADE_NUX_ICON_UNSPECIFIED' }, + { no: 1, name: 'CASCADE_NUX_ICON_WEB_SEARCH' }, + { no: 2, name: 'CASCADE_NUX_ICON_ANTIGRAVITY_BROWSER' }, + ], +); +var CascadeNUXTrigger; +(function (CascadeNUXTrigger2) { + CascadeNUXTrigger2[ + (CascadeNUXTrigger2['CASCADE_NUX_TRIGGER_UNSPECIFIED'] = 0) + ] = 'CASCADE_NUX_TRIGGER_UNSPECIFIED'; + CascadeNUXTrigger2[ + (CascadeNUXTrigger2['CASCADE_NUX_TRIGGER_PRODUCED_CODE_DIFF'] = 1) + ] = 'CASCADE_NUX_TRIGGER_PRODUCED_CODE_DIFF'; + CascadeNUXTrigger2[ + (CascadeNUXTrigger2['CASCADE_NUX_TRIGGER_OPEN_BROWSER_URL'] = 3) + ] = 'CASCADE_NUX_TRIGGER_OPEN_BROWSER_URL'; + CascadeNUXTrigger2[ + (CascadeNUXTrigger2['CASCADE_NUX_TRIGGER_WEB_SEARCH'] = 4) + ] = 'CASCADE_NUX_TRIGGER_WEB_SEARCH'; + CascadeNUXTrigger2[ + (CascadeNUXTrigger2['CASCADE_NUX_TRIGGER_MANAGER_POSTONBOARDING_COMPLETE'] = + 5) + ] = 'CASCADE_NUX_TRIGGER_MANAGER_POSTONBOARDING_COMPLETE'; + CascadeNUXTrigger2[ + (CascadeNUXTrigger2['CASCADE_NUX_TRIGGER_MANAGER_ARTIFACT_CREATED'] = 6) + ] = 'CASCADE_NUX_TRIGGER_MANAGER_ARTIFACT_CREATED'; + CascadeNUXTrigger2[ + (CascadeNUXTrigger2['CASCADE_NUX_TRIGGER_MANAGER_ARTIFACT_OPENED'] = 7) + ] = 'CASCADE_NUX_TRIGGER_MANAGER_ARTIFACT_OPENED'; + CascadeNUXTrigger2[ + (CascadeNUXTrigger2['CASCADE_NUX_TRIGGER_MANAGER_FILE_OPENED'] = 8) + ] = 'CASCADE_NUX_TRIGGER_MANAGER_FILE_OPENED'; + CascadeNUXTrigger2[ + (CascadeNUXTrigger2['CASCADE_NUX_TRIGGER_MANAGER_CONVERSATION_AVAILABLE'] = + 10) + ] = 'CASCADE_NUX_TRIGGER_MANAGER_CONVERSATION_AVAILABLE'; +})(CascadeNUXTrigger || (CascadeNUXTrigger = {})); +proto3.util.setEnumType( + CascadeNUXTrigger, + 'exa.codeium_common_pb.CascadeNUXTrigger', + [ + { no: 0, name: 'CASCADE_NUX_TRIGGER_UNSPECIFIED' }, + { no: 1, name: 'CASCADE_NUX_TRIGGER_PRODUCED_CODE_DIFF' }, + { no: 3, name: 'CASCADE_NUX_TRIGGER_OPEN_BROWSER_URL' }, + { no: 4, name: 'CASCADE_NUX_TRIGGER_WEB_SEARCH' }, + { no: 5, name: 'CASCADE_NUX_TRIGGER_MANAGER_POSTONBOARDING_COMPLETE' }, + { no: 6, name: 'CASCADE_NUX_TRIGGER_MANAGER_ARTIFACT_CREATED' }, + { no: 7, name: 'CASCADE_NUX_TRIGGER_MANAGER_ARTIFACT_OPENED' }, + { no: 8, name: 'CASCADE_NUX_TRIGGER_MANAGER_FILE_OPENED' }, + { no: 10, name: 'CASCADE_NUX_TRIGGER_MANAGER_CONVERSATION_AVAILABLE' }, + ], +); +var AnnotationsConfig; +(function (AnnotationsConfig2) { + AnnotationsConfig2[(AnnotationsConfig2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + AnnotationsConfig2[(AnnotationsConfig2['ENABLED'] = 1)] = 'ENABLED'; + AnnotationsConfig2[(AnnotationsConfig2['DISABLED'] = 2)] = 'DISABLED'; +})(AnnotationsConfig || (AnnotationsConfig = {})); +proto3.util.setEnumType( + AnnotationsConfig, + 'exa.codeium_common_pb.AnnotationsConfig', + [ + { no: 0, name: 'ANNOTATIONS_CONFIG_UNSPECIFIED' }, + { no: 1, name: 'ANNOTATIONS_CONFIG_ENABLED' }, + { no: 2, name: 'ANNOTATIONS_CONFIG_DISABLED' }, + ], +); +var DetectAndUseProxy; +(function (DetectAndUseProxy2) { + DetectAndUseProxy2[(DetectAndUseProxy2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + DetectAndUseProxy2[(DetectAndUseProxy2['ENABLED'] = 1)] = 'ENABLED'; + DetectAndUseProxy2[(DetectAndUseProxy2['DISABLED'] = 2)] = 'DISABLED'; +})(DetectAndUseProxy || (DetectAndUseProxy = {})); +proto3.util.setEnumType( + DetectAndUseProxy, + 'exa.codeium_common_pb.DetectAndUseProxy', + [ + { no: 0, name: 'DETECT_AND_USE_PROXY_UNSPECIFIED' }, + { no: 1, name: 'DETECT_AND_USE_PROXY_ENABLED' }, + { no: 2, name: 'DETECT_AND_USE_PROXY_DISABLED' }, + ], +); +var BrowserJsExecutionPolicy; +(function (BrowserJsExecutionPolicy2) { + BrowserJsExecutionPolicy2[(BrowserJsExecutionPolicy2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + BrowserJsExecutionPolicy2[(BrowserJsExecutionPolicy2['DISABLED'] = 1)] = + 'DISABLED'; + BrowserJsExecutionPolicy2[(BrowserJsExecutionPolicy2['ALWAYS_ASK'] = 2)] = + 'ALWAYS_ASK'; + BrowserJsExecutionPolicy2[(BrowserJsExecutionPolicy2['MODEL_DECIDES'] = 3)] = + 'MODEL_DECIDES'; + BrowserJsExecutionPolicy2[(BrowserJsExecutionPolicy2['TURBO'] = 4)] = 'TURBO'; +})(BrowserJsExecutionPolicy || (BrowserJsExecutionPolicy = {})); +proto3.util.setEnumType( + BrowserJsExecutionPolicy, + 'exa.codeium_common_pb.BrowserJsExecutionPolicy', + [ + { no: 0, name: 'BROWSER_JS_EXECUTION_POLICY_UNSPECIFIED' }, + { no: 1, name: 'BROWSER_JS_EXECUTION_POLICY_DISABLED' }, + { no: 2, name: 'BROWSER_JS_EXECUTION_POLICY_ALWAYS_ASK' }, + { no: 3, name: 'BROWSER_JS_EXECUTION_POLICY_MODEL_DECIDES' }, + { no: 4, name: 'BROWSER_JS_EXECUTION_POLICY_TURBO' }, + ], +); +var ModelType; +(function (ModelType2) { + ModelType2[(ModelType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ModelType2[(ModelType2['COMPLETION'] = 1)] = 'COMPLETION'; + ModelType2[(ModelType2['CHAT'] = 2)] = 'CHAT'; + ModelType2[(ModelType2['EMBED'] = 3)] = 'EMBED'; + ModelType2[(ModelType2['QUERY'] = 4)] = 'QUERY'; +})(ModelType || (ModelType = {})); +proto3.util.setEnumType(ModelType, 'exa.codeium_common_pb.ModelType', [ + { no: 0, name: 'MODEL_TYPE_UNSPECIFIED' }, + { no: 1, name: 'MODEL_TYPE_COMPLETION' }, + { no: 2, name: 'MODEL_TYPE_CHAT' }, + { no: 3, name: 'MODEL_TYPE_EMBED' }, + { no: 4, name: 'MODEL_TYPE_QUERY' }, +]); +var APIProvider; +(function (APIProvider2) { + APIProvider2[(APIProvider2['API_PROVIDER_UNSPECIFIED'] = 0)] = + 'API_PROVIDER_UNSPECIFIED'; + APIProvider2[(APIProvider2['API_PROVIDER_INTERNAL'] = 1)] = + 'API_PROVIDER_INTERNAL'; + APIProvider2[(APIProvider2['API_PROVIDER_GOOGLE_VERTEX'] = 3)] = + 'API_PROVIDER_GOOGLE_VERTEX'; + APIProvider2[(APIProvider2['API_PROVIDER_GOOGLE_GEMINI'] = 24)] = + 'API_PROVIDER_GOOGLE_GEMINI'; + APIProvider2[(APIProvider2['API_PROVIDER_ANTHROPIC_VERTEX'] = 26)] = + 'API_PROVIDER_ANTHROPIC_VERTEX'; + APIProvider2[(APIProvider2['API_PROVIDER_GOOGLE_EVERGREEN'] = 30)] = + 'API_PROVIDER_GOOGLE_EVERGREEN'; + APIProvider2[(APIProvider2['API_PROVIDER_OPENAI_VERTEX'] = 31)] = + 'API_PROVIDER_OPENAI_VERTEX'; +})(APIProvider || (APIProvider = {})); +proto3.util.setEnumType(APIProvider, 'exa.codeium_common_pb.APIProvider', [ + { no: 0, name: 'API_PROVIDER_UNSPECIFIED' }, + { no: 1, name: 'API_PROVIDER_INTERNAL' }, + { no: 3, name: 'API_PROVIDER_GOOGLE_VERTEX' }, + { no: 24, name: 'API_PROVIDER_GOOGLE_GEMINI' }, + { no: 26, name: 'API_PROVIDER_ANTHROPIC_VERTEX' }, + { no: 30, name: 'API_PROVIDER_GOOGLE_EVERGREEN' }, + { no: 31, name: 'API_PROVIDER_OPENAI_VERTEX' }, +]); +var ModelStatus; +(function (ModelStatus2) { + ModelStatus2[(ModelStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ModelStatus2[(ModelStatus2['INFO'] = 1)] = 'INFO'; + ModelStatus2[(ModelStatus2['WARNING'] = 2)] = 'WARNING'; +})(ModelStatus || (ModelStatus = {})); +proto3.util.setEnumType(ModelStatus, 'exa.codeium_common_pb.ModelStatus', [ + { no: 0, name: 'MODEL_STATUS_UNSPECIFIED' }, + { no: 1, name: 'MODEL_STATUS_INFO' }, + { no: 2, name: 'MODEL_STATUS_WARNING' }, +]); +var CodeSource; +(function (CodeSource2) { + CodeSource2[(CodeSource2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CodeSource2[(CodeSource2['BASE'] = 1)] = 'BASE'; + CodeSource2[(CodeSource2['CODEIUM'] = 2)] = 'CODEIUM'; + CodeSource2[(CodeSource2['USER'] = 3)] = 'USER'; + CodeSource2[(CodeSource2['USER_LARGE'] = 4)] = 'USER_LARGE'; + CodeSource2[(CodeSource2['UNKNOWN'] = 5)] = 'UNKNOWN'; +})(CodeSource || (CodeSource = {})); +proto3.util.setEnumType(CodeSource, 'exa.codeium_common_pb.CodeSource', [ + { no: 0, name: 'CODE_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'CODE_SOURCE_BASE' }, + { no: 2, name: 'CODE_SOURCE_CODEIUM' }, + { no: 3, name: 'CODE_SOURCE_USER' }, + { no: 4, name: 'CODE_SOURCE_USER_LARGE' }, + { no: 5, name: 'CODE_SOURCE_UNKNOWN' }, +]); +var DocumentType; +(function (DocumentType2) { + DocumentType2[(DocumentType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + DocumentType2[(DocumentType2['SLACK_MESSAGE'] = 1)] = 'SLACK_MESSAGE'; + DocumentType2[(DocumentType2['SLACK_CHANNEL'] = 2)] = 'SLACK_CHANNEL'; + DocumentType2[(DocumentType2['GITHUB_ISSUE'] = 3)] = 'GITHUB_ISSUE'; + DocumentType2[(DocumentType2['GITHUB_ISSUE_COMMENT'] = 4)] = + 'GITHUB_ISSUE_COMMENT'; + DocumentType2[(DocumentType2['GITHUB_REPO'] = 8)] = 'GITHUB_REPO'; + DocumentType2[(DocumentType2['GOOGLE_DRIVE_FILE'] = 5)] = 'GOOGLE_DRIVE_FILE'; + DocumentType2[(DocumentType2['GOOGLE_DRIVE_FOLDER'] = 6)] = + 'GOOGLE_DRIVE_FOLDER'; + DocumentType2[(DocumentType2['JIRA_ISSUE'] = 7)] = 'JIRA_ISSUE'; + DocumentType2[(DocumentType2['CCI'] = 9)] = 'CCI'; +})(DocumentType || (DocumentType = {})); +proto3.util.setEnumType(DocumentType, 'exa.codeium_common_pb.DocumentType', [ + { no: 0, name: 'DOCUMENT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'DOCUMENT_TYPE_SLACK_MESSAGE' }, + { no: 2, name: 'DOCUMENT_TYPE_SLACK_CHANNEL' }, + { no: 3, name: 'DOCUMENT_TYPE_GITHUB_ISSUE' }, + { no: 4, name: 'DOCUMENT_TYPE_GITHUB_ISSUE_COMMENT' }, + { no: 8, name: 'DOCUMENT_TYPE_GITHUB_REPO' }, + { no: 5, name: 'DOCUMENT_TYPE_GOOGLE_DRIVE_FILE' }, + { no: 6, name: 'DOCUMENT_TYPE_GOOGLE_DRIVE_FOLDER' }, + { no: 7, name: 'DOCUMENT_TYPE_JIRA_ISSUE' }, + { no: 9, name: 'DOCUMENT_TYPE_CCI' }, +]); +var ContextScopeType; +(function (ContextScopeType2) { + ContextScopeType2[(ContextScopeType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ContextScopeType2[(ContextScopeType2['FILE'] = 1)] = 'FILE'; + ContextScopeType2[(ContextScopeType2['DIRECTORY'] = 2)] = 'DIRECTORY'; + ContextScopeType2[(ContextScopeType2['REPOSITORY'] = 3)] = 'REPOSITORY'; + ContextScopeType2[(ContextScopeType2['CODE_CONTEXT'] = 4)] = 'CODE_CONTEXT'; + ContextScopeType2[(ContextScopeType2['CCI_WITH_SUBRANGE'] = 5)] = + 'CCI_WITH_SUBRANGE'; + ContextScopeType2[(ContextScopeType2['REPOSITORY_PATH'] = 6)] = + 'REPOSITORY_PATH'; + ContextScopeType2[(ContextScopeType2['SLACK'] = 7)] = 'SLACK'; + ContextScopeType2[(ContextScopeType2['GITHUB'] = 8)] = 'GITHUB'; + ContextScopeType2[(ContextScopeType2['FILE_LINE_RANGE'] = 9)] = + 'FILE_LINE_RANGE'; + ContextScopeType2[(ContextScopeType2['TEXT_BLOCK'] = 10)] = 'TEXT_BLOCK'; + ContextScopeType2[(ContextScopeType2['JIRA'] = 11)] = 'JIRA'; + ContextScopeType2[(ContextScopeType2['GOOGLE_DRIVE'] = 12)] = 'GOOGLE_DRIVE'; + ContextScopeType2[(ContextScopeType2['CONSOLE_LOG'] = 13)] = 'CONSOLE_LOG'; + ContextScopeType2[(ContextScopeType2['DOM_ELEMENT'] = 14)] = 'DOM_ELEMENT'; + ContextScopeType2[(ContextScopeType2['RECIPE'] = 15)] = 'RECIPE'; + ContextScopeType2[(ContextScopeType2['KNOWLEDGE'] = 16)] = 'KNOWLEDGE'; + ContextScopeType2[(ContextScopeType2['RULE'] = 17)] = 'RULE'; + ContextScopeType2[(ContextScopeType2['MCP_RESOURCE'] = 18)] = 'MCP_RESOURCE'; + ContextScopeType2[(ContextScopeType2['BROWSER_PAGE'] = 19)] = 'BROWSER_PAGE'; + ContextScopeType2[(ContextScopeType2['BROWSER_CODE_BLOCK'] = 20)] = + 'BROWSER_CODE_BLOCK'; + ContextScopeType2[(ContextScopeType2['BROWSER_TEXT'] = 21)] = 'BROWSER_TEXT'; + ContextScopeType2[(ContextScopeType2['CONVERSATION'] = 22)] = 'CONVERSATION'; + ContextScopeType2[(ContextScopeType2['USER_ACTIVITY'] = 23)] = + 'USER_ACTIVITY'; + ContextScopeType2[(ContextScopeType2['TERMINAL'] = 24)] = 'TERMINAL'; +})(ContextScopeType || (ContextScopeType = {})); +proto3.util.setEnumType( + ContextScopeType, + 'exa.codeium_common_pb.ContextScopeType', + [ + { no: 0, name: 'CONTEXT_SCOPE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CONTEXT_SCOPE_TYPE_FILE' }, + { no: 2, name: 'CONTEXT_SCOPE_TYPE_DIRECTORY' }, + { no: 3, name: 'CONTEXT_SCOPE_TYPE_REPOSITORY' }, + { no: 4, name: 'CONTEXT_SCOPE_TYPE_CODE_CONTEXT' }, + { no: 5, name: 'CONTEXT_SCOPE_TYPE_CCI_WITH_SUBRANGE' }, + { no: 6, name: 'CONTEXT_SCOPE_TYPE_REPOSITORY_PATH' }, + { no: 7, name: 'CONTEXT_SCOPE_TYPE_SLACK' }, + { no: 8, name: 'CONTEXT_SCOPE_TYPE_GITHUB' }, + { no: 9, name: 'CONTEXT_SCOPE_TYPE_FILE_LINE_RANGE' }, + { no: 10, name: 'CONTEXT_SCOPE_TYPE_TEXT_BLOCK' }, + { no: 11, name: 'CONTEXT_SCOPE_TYPE_JIRA' }, + { no: 12, name: 'CONTEXT_SCOPE_TYPE_GOOGLE_DRIVE' }, + { no: 13, name: 'CONTEXT_SCOPE_TYPE_CONSOLE_LOG' }, + { no: 14, name: 'CONTEXT_SCOPE_TYPE_DOM_ELEMENT' }, + { no: 15, name: 'CONTEXT_SCOPE_TYPE_RECIPE' }, + { no: 16, name: 'CONTEXT_SCOPE_TYPE_KNOWLEDGE' }, + { no: 17, name: 'CONTEXT_SCOPE_TYPE_RULE' }, + { no: 18, name: 'CONTEXT_SCOPE_TYPE_MCP_RESOURCE' }, + { no: 19, name: 'CONTEXT_SCOPE_TYPE_BROWSER_PAGE' }, + { no: 20, name: 'CONTEXT_SCOPE_TYPE_BROWSER_CODE_BLOCK' }, + { no: 21, name: 'CONTEXT_SCOPE_TYPE_BROWSER_TEXT' }, + { no: 22, name: 'CONTEXT_SCOPE_TYPE_CONVERSATION' }, + { no: 23, name: 'CONTEXT_SCOPE_TYPE_USER_ACTIVITY' }, + { no: 24, name: 'CONTEXT_SCOPE_TYPE_TERMINAL' }, + ], +); +var StatusLevel; +(function (StatusLevel2) { + StatusLevel2[(StatusLevel2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + StatusLevel2[(StatusLevel2['ERROR'] = 1)] = 'ERROR'; + StatusLevel2[(StatusLevel2['WARNING'] = 2)] = 'WARNING'; + StatusLevel2[(StatusLevel2['INFO'] = 3)] = 'INFO'; + StatusLevel2[(StatusLevel2['DEBUG'] = 4)] = 'DEBUG'; +})(StatusLevel || (StatusLevel = {})); +proto3.util.setEnumType(StatusLevel, 'exa.codeium_common_pb.StatusLevel', [ + { no: 0, name: 'STATUS_LEVEL_UNSPECIFIED' }, + { no: 1, name: 'STATUS_LEVEL_ERROR' }, + { no: 2, name: 'STATUS_LEVEL_WARNING' }, + { no: 3, name: 'STATUS_LEVEL_INFO' }, + { no: 4, name: 'STATUS_LEVEL_DEBUG' }, +]); +var CortexErrorCategory; +(function (CortexErrorCategory2) { + CortexErrorCategory2[(CortexErrorCategory2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CortexErrorCategory2[(CortexErrorCategory2['OVERALL'] = 1)] = 'OVERALL'; + CortexErrorCategory2[(CortexErrorCategory2['ACTION_PREPARE'] = 2)] = + 'ACTION_PREPARE'; + CortexErrorCategory2[(CortexErrorCategory2['ACTION_APPLY'] = 3)] = + 'ACTION_APPLY'; +})(CortexErrorCategory || (CortexErrorCategory = {})); +proto3.util.setEnumType( + CortexErrorCategory, + 'exa.codeium_common_pb.CortexErrorCategory', + [ + { no: 0, name: 'CORTEX_ERROR_CATEGORY_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_ERROR_CATEGORY_OVERALL' }, + { no: 2, name: 'CORTEX_ERROR_CATEGORY_ACTION_PREPARE' }, + { no: 3, name: 'CORTEX_ERROR_CATEGORY_ACTION_APPLY' }, + ], +); +var LastUpdateType; +(function (LastUpdateType2) { + LastUpdateType2[(LastUpdateType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + LastUpdateType2[(LastUpdateType2['OVERALL'] = 1)] = 'OVERALL'; + LastUpdateType2[(LastUpdateType2['LAST_AUTOCOMPLETE_USAGE_TIME'] = 2)] = + 'LAST_AUTOCOMPLETE_USAGE_TIME'; + LastUpdateType2[(LastUpdateType2['LAST_CHAT_USAGE_TIME'] = 3)] = + 'LAST_CHAT_USAGE_TIME'; + LastUpdateType2[(LastUpdateType2['LAST_COMMAND_USAGE_TIME'] = 4)] = + 'LAST_COMMAND_USAGE_TIME'; +})(LastUpdateType || (LastUpdateType = {})); +proto3.util.setEnumType( + LastUpdateType, + 'exa.codeium_common_pb.LastUpdateType', + [ + { no: 0, name: 'LAST_UPDATE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'LAST_UPDATE_TYPE_OVERALL' }, + { no: 2, name: 'LAST_UPDATE_TYPE_LAST_AUTOCOMPLETE_USAGE_TIME' }, + { no: 3, name: 'LAST_UPDATE_TYPE_LAST_CHAT_USAGE_TIME' }, + { no: 4, name: 'LAST_UPDATE_TYPE_LAST_COMMAND_USAGE_TIME' }, + ], +); +var OnboardingActionType; +(function (OnboardingActionType2) { + OnboardingActionType2[(OnboardingActionType2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + OnboardingActionType2[(OnboardingActionType2['AUTOCOMPLETE'] = 1)] = + 'AUTOCOMPLETE'; + OnboardingActionType2[(OnboardingActionType2['COMMAND'] = 2)] = 'COMMAND'; + OnboardingActionType2[(OnboardingActionType2['CHAT'] = 3)] = 'CHAT'; +})(OnboardingActionType || (OnboardingActionType = {})); +proto3.util.setEnumType( + OnboardingActionType, + 'exa.codeium_common_pb.OnboardingActionType', + [ + { no: 0, name: 'ONBOARDING_ACTION_TYPE_UNSPECIFIED' }, + { no: 1, name: 'ONBOARDING_ACTION_TYPE_AUTOCOMPLETE' }, + { no: 2, name: 'ONBOARDING_ACTION_TYPE_COMMAND' }, + { no: 3, name: 'ONBOARDING_ACTION_TYPE_CHAT' }, + ], +); +var SupercompleteTriggerCondition; +(function (SupercompleteTriggerCondition2) { + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['AUTOCOMPLETE_ACCEPT'] = 1) + ] = 'AUTOCOMPLETE_ACCEPT'; + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['CURSOR_LINE_NAVIGATION'] = 2) + ] = 'CURSOR_LINE_NAVIGATION'; + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['TYPING'] = 3) + ] = 'TYPING'; + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['FORCED'] = 4) + ] = 'FORCED'; + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['TAB_JUMP_ACCEPT'] = 5) + ] = 'TAB_JUMP_ACCEPT'; + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['SUPERCOMPLETE_ACCEPT'] = 6) + ] = 'SUPERCOMPLETE_ACCEPT'; + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['TAB_JUMP_PREDICTIVE'] = 7) + ] = 'TAB_JUMP_PREDICTIVE'; + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['AUTOCOMPLETE_PREDICTIVE'] = 8) + ] = 'AUTOCOMPLETE_PREDICTIVE'; + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['SUPERCOMPLETE_PREDICTIVE'] = 9) + ] = 'SUPERCOMPLETE_PREDICTIVE'; + SupercompleteTriggerCondition2[ + (SupercompleteTriggerCondition2['TAB_JUMP_EDIT'] = 10) + ] = 'TAB_JUMP_EDIT'; +})(SupercompleteTriggerCondition || (SupercompleteTriggerCondition = {})); +proto3.util.setEnumType( + SupercompleteTriggerCondition, + 'exa.codeium_common_pb.SupercompleteTriggerCondition', + [ + { no: 0, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_UNSPECIFIED' }, + { no: 1, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_AUTOCOMPLETE_ACCEPT' }, + { no: 2, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_CURSOR_LINE_NAVIGATION' }, + { no: 3, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_TYPING' }, + { no: 4, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_FORCED' }, + { no: 5, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_TAB_JUMP_ACCEPT' }, + { no: 6, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_SUPERCOMPLETE_ACCEPT' }, + { no: 7, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_TAB_JUMP_PREDICTIVE' }, + { no: 8, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_AUTOCOMPLETE_PREDICTIVE' }, + { no: 9, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_SUPERCOMPLETE_PREDICTIVE' }, + { no: 10, name: 'SUPERCOMPLETE_TRIGGER_CONDITION_TAB_JUMP_EDIT' }, + ], +); +var ProductEventType; +(function (ProductEventType2) { + ProductEventType2[(ProductEventType2['EVENT_UNSPECIFIED'] = 0)] = + 'EVENT_UNSPECIFIED'; + ProductEventType2[(ProductEventType2['ANTIGRAVITY_EDITOR_READY'] = 251)] = + 'ANTIGRAVITY_EDITOR_READY'; + ProductEventType2[(ProductEventType2['ANTIGRAVITY_EXTENSION_START'] = 253)] = + 'ANTIGRAVITY_EXTENSION_START'; + ProductEventType2[ + (ProductEventType2['ANTIGRAVITY_EXTENSION_ACTIVATED'] = 32) + ] = 'ANTIGRAVITY_EXTENSION_ACTIVATED'; + ProductEventType2[(ProductEventType2['LS_DOWNLOAD_START'] = 1)] = + 'LS_DOWNLOAD_START'; + ProductEventType2[(ProductEventType2['LS_DOWNLOAD_COMPLETE'] = 2)] = + 'LS_DOWNLOAD_COMPLETE'; + ProductEventType2[(ProductEventType2['LS_DOWNLOAD_FAILURE'] = 5)] = + 'LS_DOWNLOAD_FAILURE'; + ProductEventType2[(ProductEventType2['LS_BINARY_STARTUP'] = 250)] = + 'LS_BINARY_STARTUP'; + ProductEventType2[(ProductEventType2['LS_STARTUP'] = 3)] = 'LS_STARTUP'; + ProductEventType2[(ProductEventType2['LS_FAILURE'] = 4)] = 'LS_FAILURE'; + ProductEventType2[(ProductEventType2['AUTOCOMPLETE_ACCEPTED'] = 6)] = + 'AUTOCOMPLETE_ACCEPTED'; + ProductEventType2[(ProductEventType2['AUTOCOMPLETE_ONE_WORD_ACCEPTED'] = 7)] = + 'AUTOCOMPLETE_ONE_WORD_ACCEPTED'; + ProductEventType2[(ProductEventType2['CHAT_MESSAGE_SENT'] = 8)] = + 'CHAT_MESSAGE_SENT'; + ProductEventType2[(ProductEventType2['CHAT_MENTION_INSERT'] = 13)] = + 'CHAT_MENTION_INSERT'; + ProductEventType2[(ProductEventType2['CHAT_MENTION_MENU_OPEN'] = 19)] = + 'CHAT_MENTION_MENU_OPEN'; + ProductEventType2[(ProductEventType2['CHAT_OPEN_SETTINGS'] = 14)] = + 'CHAT_OPEN_SETTINGS'; + ProductEventType2[(ProductEventType2['CHAT_OPEN_CONTEXT_SETTINGS'] = 15)] = + 'CHAT_OPEN_CONTEXT_SETTINGS'; + ProductEventType2[(ProductEventType2['CHAT_WITH_CODEBASE'] = 16)] = + 'CHAT_WITH_CODEBASE'; + ProductEventType2[(ProductEventType2['CHAT_NEW_CONVERSATION'] = 17)] = + 'CHAT_NEW_CONVERSATION'; + ProductEventType2[(ProductEventType2['CHAT_CHANGE_MODEL'] = 18)] = + 'CHAT_CHANGE_MODEL'; + ProductEventType2[(ProductEventType2['CHAT_TOGGLE_FOCUS_INSERT_TEXT'] = 34)] = + 'CHAT_TOGGLE_FOCUS_INSERT_TEXT'; + ProductEventType2[(ProductEventType2['FUNCTION_REFACTOR'] = 28)] = + 'FUNCTION_REFACTOR'; + ProductEventType2[(ProductEventType2['EXPLAIN_CODE_BLOCK'] = 29)] = + 'EXPLAIN_CODE_BLOCK'; + ProductEventType2[(ProductEventType2['FUNCTION_ADD_DOCSTRING'] = 30)] = + 'FUNCTION_ADD_DOCSTRING'; + ProductEventType2[(ProductEventType2['EXPLAIN_PROBLEM'] = 31)] = + 'EXPLAIN_PROBLEM'; + ProductEventType2[(ProductEventType2['COMMAND_BOX_OPENED'] = 9)] = + 'COMMAND_BOX_OPENED'; + ProductEventType2[(ProductEventType2['COMMAND_SUBMITTED'] = 10)] = + 'COMMAND_SUBMITTED'; + ProductEventType2[(ProductEventType2['COMMAND_ACCEPTED'] = 11)] = + 'COMMAND_ACCEPTED'; + ProductEventType2[(ProductEventType2['COMMAND_REJECTED'] = 12)] = + 'COMMAND_REJECTED'; + ProductEventType2[ + (ProductEventType2['WS_ONBOARDING_LANDING_PAGE_OPENED'] = 20) + ] = 'WS_ONBOARDING_LANDING_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['WS_ONBOARDING_SETUP_PAGE_OPENED'] = 21) + ] = 'WS_ONBOARDING_SETUP_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['WS_ONBOARDING_KEYBINDINGS_PAGE_OPENED'] = 22) + ] = 'WS_ONBOARDING_KEYBINDINGS_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['WS_ONBOARDING_MIGRATION_SCOPE_PAGE_OPENED'] = 23) + ] = 'WS_ONBOARDING_MIGRATION_SCOPE_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['WS_ONBOARDING_IMPORT_PAGE_OPENED'] = 24) + ] = 'WS_ONBOARDING_IMPORT_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['WS_ONBOARDING_AUTH_PAGE_OPENED'] = 25) + ] = 'WS_ONBOARDING_AUTH_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['WS_ONBOARDING_AUTH_MANUAL_PAGE_OPENED'] = 26) + ] = 'WS_ONBOARDING_AUTH_MANUAL_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['WS_ONBOARDING_CHOOSE_THEME_PAGE_OPENED'] = 35) + ] = 'WS_ONBOARDING_CHOOSE_THEME_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['AGY_ONBOARDING_TERMS_OF_USE_PAGE_OPENED'] = 231) + ] = 'AGY_ONBOARDING_TERMS_OF_USE_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['AGY_ONBOARDING_AGENT_CONFIG_PAGE_OPENED'] = 232) + ] = 'AGY_ONBOARDING_AGENT_CONFIG_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['AGY_ONBOARDING_USAGE_MODE_PAGE_OPENED'] = 233) + ] = 'AGY_ONBOARDING_USAGE_MODE_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['AGY_ONBOARDING_INSTALL_EXTENSIONS'] = 234) + ] = 'AGY_ONBOARDING_INSTALL_EXTENSIONS'; + ProductEventType2[(ProductEventType2['WS_ONBOARDING_COMPLETED'] = 27)] = + 'WS_ONBOARDING_COMPLETED'; + ProductEventType2[(ProductEventType2['WS_SKIPPED_ONBOARDING'] = 69)] = + 'WS_SKIPPED_ONBOARDING'; + ProductEventType2[(ProductEventType2['WS_SETTINGS_PAGE_OPEN'] = 72)] = + 'WS_SETTINGS_PAGE_OPEN'; + ProductEventType2[ + (ProductEventType2['WS_SETTINGS_PAGE_OPEN_WITH_SETTING_FOCUS'] = 73) + ] = 'WS_SETTINGS_PAGE_OPEN_WITH_SETTING_FOCUS'; + ProductEventType2[(ProductEventType2['EMPTY_WORKSPACE_PAGE_OPENED'] = 209)] = + 'EMPTY_WORKSPACE_PAGE_OPENED'; + ProductEventType2[ + (ProductEventType2['EMPTY_WORKSPACE_PAGE_RECENT_FOLDERS_CLICKED'] = 210) + ] = 'EMPTY_WORKSPACE_PAGE_RECENT_FOLDERS_CLICKED'; + ProductEventType2[ + (ProductEventType2['EMPTY_WORKSPACE_PAGE_OPEN_FOLDER_CLICKED'] = 211) + ] = 'EMPTY_WORKSPACE_PAGE_OPEN_FOLDER_CLICKED'; + ProductEventType2[ + (ProductEventType2['EMPTY_WORKSPACE_PAGE_GENERATE_PROJECT_CLICKED'] = 212) + ] = 'EMPTY_WORKSPACE_PAGE_GENERATE_PROJECT_CLICKED'; + ProductEventType2[(ProductEventType2['PROVIDE_FEEDBACK'] = 33)] = + 'PROVIDE_FEEDBACK'; + ProductEventType2[(ProductEventType2['CASCADE_MESSAGE_SENT'] = 36)] = + 'CASCADE_MESSAGE_SENT'; + ProductEventType2[ + (ProductEventType2['WS_OPEN_CASCADE_MEMORIES_PANEL'] = 38) + ] = 'WS_OPEN_CASCADE_MEMORIES_PANEL'; + ProductEventType2[(ProductEventType2['PROVIDE_MESSAGE_FEEDBACK'] = 41)] = + 'PROVIDE_MESSAGE_FEEDBACK'; + ProductEventType2[(ProductEventType2['CASCADE_MEMORY_DELETED'] = 42)] = + 'CASCADE_MEMORY_DELETED'; + ProductEventType2[(ProductEventType2['CASCADE_STEP_COMPLETED'] = 43)] = + 'CASCADE_STEP_COMPLETED'; + ProductEventType2[(ProductEventType2['ACKNOWLEDGE_CASCADE_CODE_EDIT'] = 44)] = + 'ACKNOWLEDGE_CASCADE_CODE_EDIT'; + ProductEventType2[ + (ProductEventType2['CASCADE_WEB_TOOLS_OPEN_READ_URL_MARKDOWN'] = 45) + ] = 'CASCADE_WEB_TOOLS_OPEN_READ_URL_MARKDOWN'; + ProductEventType2[ + (ProductEventType2['CASCADE_WEB_TOOLS_OPEN_CHUNK_MARKDOWN'] = 46) + ] = 'CASCADE_WEB_TOOLS_OPEN_CHUNK_MARKDOWN'; + ProductEventType2[(ProductEventType2['CASCADE_MCP_SERVER_INIT'] = 64)] = + 'CASCADE_MCP_SERVER_INIT'; + ProductEventType2[ + (ProductEventType2['CASCADE_KNOWLEDGE_BASE_ITEM_OPENED'] = 113) + ] = 'CASCADE_KNOWLEDGE_BASE_ITEM_OPENED'; + ProductEventType2[(ProductEventType2['CASCADE_VIEW_LOADED'] = 119)] = + 'CASCADE_VIEW_LOADED'; + ProductEventType2[ + (ProductEventType2['CASCADE_CONTEXT_SCOPE_ITEM_ATTACHED'] = 173) + ] = 'CASCADE_CONTEXT_SCOPE_ITEM_ATTACHED'; + ProductEventType2[(ProductEventType2['CASCADE_CLICK_EVENT'] = 65)] = + 'CASCADE_CLICK_EVENT'; + ProductEventType2[(ProductEventType2['CASCADE_IMPRESSION_EVENT'] = 67)] = + 'CASCADE_IMPRESSION_EVENT'; + ProductEventType2[(ProductEventType2['OPEN_CHANGELOG'] = 37)] = + 'OPEN_CHANGELOG'; + ProductEventType2[(ProductEventType2['CURSOR_DETECTED'] = 39)] = + 'CURSOR_DETECTED'; + ProductEventType2[(ProductEventType2['VSCODE_DETECTED'] = 40)] = + 'VSCODE_DETECTED'; + ProductEventType2[(ProductEventType2['JETBRAINS_DETECTED'] = 153)] = + 'JETBRAINS_DETECTED'; + ProductEventType2[ + (ProductEventType2['CROSS_SELL_EXTENSION_DOWNLOAD_ANTIGRAVITY_CLICK'] = 47) + ] = 'CROSS_SELL_EXTENSION_DOWNLOAD_ANTIGRAVITY_CLICK'; + ProductEventType2[ + (ProductEventType2[ + 'CROSS_SELL_EXTENSION_DOWNLOAD_ANTIGRAVITY_NUDGE_IMPRESSION' + ] = 48) + ] = 'CROSS_SELL_EXTENSION_DOWNLOAD_ANTIGRAVITY_NUDGE_IMPRESSION'; + ProductEventType2[ + (ProductEventType2['WS_PROBLEMS_TAB_SEND_ALL_TO_CASCADE'] = 49) + ] = 'WS_PROBLEMS_TAB_SEND_ALL_TO_CASCADE'; + ProductEventType2[ + (ProductEventType2['WS_PROBLEMS_TAB_SEND_ALL_IN_FILE_TO_CASCADE'] = 50) + ] = 'WS_PROBLEMS_TAB_SEND_ALL_IN_FILE_TO_CASCADE'; + ProductEventType2[(ProductEventType2['WS_CASCADE_BAR_FILE_NAV'] = 51)] = + 'WS_CASCADE_BAR_FILE_NAV'; + ProductEventType2[(ProductEventType2['WS_CASCADE_BAR_HUNK_NAV'] = 52)] = + 'WS_CASCADE_BAR_HUNK_NAV'; + ProductEventType2[(ProductEventType2['WS_CASCADE_BAR_ACCEPT_FILE'] = 53)] = + 'WS_CASCADE_BAR_ACCEPT_FILE'; + ProductEventType2[(ProductEventType2['WS_CASCADE_BAR_REJECT_FILE'] = 54)] = + 'WS_CASCADE_BAR_REJECT_FILE'; + ProductEventType2[(ProductEventType2['WS_CUSTOM_APP_ICON_MODAL_OPEN'] = 55)] = + 'WS_CUSTOM_APP_ICON_MODAL_OPEN'; + ProductEventType2[ + (ProductEventType2['WS_CUSTOM_APP_ICON_SELECT_CLASSIC'] = 56) + ] = 'WS_CUSTOM_APP_ICON_SELECT_CLASSIC'; + ProductEventType2[ + (ProductEventType2['WS_CUSTOM_APP_ICON_SELECT_CLASSIC_LIGHT'] = 57) + ] = 'WS_CUSTOM_APP_ICON_SELECT_CLASSIC_LIGHT'; + ProductEventType2[ + (ProductEventType2['WS_CUSTOM_APP_ICON_SELECT_RETRO'] = 58) + ] = 'WS_CUSTOM_APP_ICON_SELECT_RETRO'; + ProductEventType2[ + (ProductEventType2['WS_CUSTOM_APP_ICON_SELECT_BLUEPRINT'] = 59) + ] = 'WS_CUSTOM_APP_ICON_SELECT_BLUEPRINT'; + ProductEventType2[ + (ProductEventType2['WS_CUSTOM_APP_ICON_SELECT_HAND_DRAWN'] = 60) + ] = 'WS_CUSTOM_APP_ICON_SELECT_HAND_DRAWN'; + ProductEventType2[ + (ProductEventType2['WS_CUSTOM_APP_ICON_SELECT_SUNSET'] = 61) + ] = 'WS_CUSTOM_APP_ICON_SELECT_SUNSET'; + ProductEventType2[ + (ProductEventType2['WS_CUSTOM_APP_ICON_SELECT_VALENTINE'] = 66) + ] = 'WS_CUSTOM_APP_ICON_SELECT_VALENTINE'; + ProductEventType2[ + (ProductEventType2['WS_CUSTOM_APP_ICON_SELECT_PIXEL_SURF'] = 82) + ] = 'WS_CUSTOM_APP_ICON_SELECT_PIXEL_SURF'; + ProductEventType2[(ProductEventType2['ENTERED_MCP_TOOLBAR_TAB'] = 63)] = + 'ENTERED_MCP_TOOLBAR_TAB'; + ProductEventType2[(ProductEventType2['CLICKED_TO_CONFIGURE_MCP'] = 62)] = + 'CLICKED_TO_CONFIGURE_MCP'; + ProductEventType2[(ProductEventType2['WS_SETTINGS_UPDATED'] = 68)] = + 'WS_SETTINGS_UPDATED'; + ProductEventType2[(ProductEventType2['BROWSER_PREVIEW_DOM_ELEMENT'] = 70)] = + 'BROWSER_PREVIEW_DOM_ELEMENT'; + ProductEventType2[ + (ProductEventType2['BROWSER_PREVIEW_CONSOLE_OUTPUT'] = 71) + ] = 'BROWSER_PREVIEW_CONSOLE_OUTPUT'; + ProductEventType2[(ProductEventType2['WS_SETTINGS_CHANGED_BY_USER'] = 74)] = + 'WS_SETTINGS_CHANGED_BY_USER'; + ProductEventType2[ + (ProductEventType2['WS_GENERATE_COMMIT_MESSAGE_CLICKED'] = 75) + ] = 'WS_GENERATE_COMMIT_MESSAGE_CLICKED'; + ProductEventType2[ + (ProductEventType2['WS_GENERATE_COMMIT_MESSAGE_ERRORED'] = 76) + ] = 'WS_GENERATE_COMMIT_MESSAGE_ERRORED'; + ProductEventType2[ + (ProductEventType2['WS_CLICKED_COMMIT_FROM_SCM_PANEL'] = 77) + ] = 'WS_CLICKED_COMMIT_FROM_SCM_PANEL'; + ProductEventType2[ + (ProductEventType2['WS_CANCELED_GENERATE_COMMIT_MESSAGE'] = 79) + ] = 'WS_CANCELED_GENERATE_COMMIT_MESSAGE'; + ProductEventType2[(ProductEventType2['USING_DEV_EXTENSION'] = 78)] = + 'USING_DEV_EXTENSION'; + ProductEventType2[ + (ProductEventType2['WS_APP_DEPLOYMENT_CREATE_PROJECT'] = 80) + ] = 'WS_APP_DEPLOYMENT_CREATE_PROJECT'; + ProductEventType2[ + (ProductEventType2['WS_APP_DEPLOYMENT_DEPLOY_PROJECT'] = 81) + ] = 'WS_APP_DEPLOYMENT_DEPLOY_PROJECT'; + ProductEventType2[ + (ProductEventType2['CASCADE_OPEN_ACTIVE_CONVERSATION_DROPDOWN'] = 114) + ] = 'CASCADE_OPEN_ACTIVE_CONVERSATION_DROPDOWN'; + ProductEventType2[ + (ProductEventType2['CASCADE_SELECT_ACTIVE_CONVERSATION_ON_DROPDOWN'] = 115) + ] = 'CASCADE_SELECT_ACTIVE_CONVERSATION_ON_DROPDOWN'; + ProductEventType2[ + (ProductEventType2['CASCADE_NAVIGATE_ACTIVE_CONVERSATION_ON_DROPDOWN'] = + 122) + ] = 'CASCADE_NAVIGATE_ACTIVE_CONVERSATION_ON_DROPDOWN'; + ProductEventType2[ + (ProductEventType2['CASCADE_SNOOZE_CONVERSATION_ON_DROPDOWN'] = 123) + ] = 'CASCADE_SNOOZE_CONVERSATION_ON_DROPDOWN'; + ProductEventType2[ + (ProductEventType2['CASCADE_TOGGLE_NOTIFICATION_ON_DROPDOWN'] = 124) + ] = 'CASCADE_TOGGLE_NOTIFICATION_ON_DROPDOWN'; + ProductEventType2[ + (ProductEventType2['CASCADE_SELECT_NOTIFICATION_ON_DROPDOWN'] = 125) + ] = 'CASCADE_SELECT_NOTIFICATION_ON_DROPDOWN'; + ProductEventType2[ + (ProductEventType2['CASCADE_NAVIGATE_NOTIFICATION_ON_DROPDOWN'] = 126) + ] = 'CASCADE_NAVIGATE_NOTIFICATION_ON_DROPDOWN'; + ProductEventType2[ + (ProductEventType2['CASCADE_DISMISS_NOTIFICATION_ON_DROPDOWN'] = 127) + ] = 'CASCADE_DISMISS_NOTIFICATION_ON_DROPDOWN'; + ProductEventType2[ + (ProductEventType2['CASCADE_TRAJECTORY_SHARE_COPY_LINK'] = 137) + ] = 'CASCADE_TRAJECTORY_SHARE_COPY_LINK'; + ProductEventType2[ + (ProductEventType2['CASCADE_TRAJECTORY_SHARE_CREATE_LINK'] = 138) + ] = 'CASCADE_TRAJECTORY_SHARE_CREATE_LINK'; + ProductEventType2[ + (ProductEventType2['CASCADE_CUSTOMIZATIONS_TAB_CHANGE'] = 139) + ] = 'CASCADE_CUSTOMIZATIONS_TAB_CHANGE'; + ProductEventType2[(ProductEventType2['CASCADE_WORKFLOW_OPEN'] = 140)] = + 'CASCADE_WORKFLOW_OPEN'; + ProductEventType2[(ProductEventType2['CASCADE_NEW_WORKFLOW_CLICKED'] = 141)] = + 'CASCADE_NEW_WORKFLOW_CLICKED'; + ProductEventType2[ + (ProductEventType2['CASCADE_NEW_GLOBAL_WORKFLOW_CLICKED'] = 184) + ] = 'CASCADE_NEW_GLOBAL_WORKFLOW_CLICKED'; + ProductEventType2[ + (ProductEventType2['CASCADE_WORKFLOW_REFRESH_CLICKED'] = 142) + ] = 'CASCADE_WORKFLOW_REFRESH_CLICKED'; + ProductEventType2[(ProductEventType2['CASCADE_RULE_OPEN'] = 143)] = + 'CASCADE_RULE_OPEN'; + ProductEventType2[(ProductEventType2['CASCADE_NEW_RULE_CLICKED'] = 144)] = + 'CASCADE_NEW_RULE_CLICKED'; + ProductEventType2[ + (ProductEventType2['CASCADE_NEW_GLOBAL_RULE_CLICKED'] = 145) + ] = 'CASCADE_NEW_GLOBAL_RULE_CLICKED'; + ProductEventType2[(ProductEventType2['CASCADE_RULE_REFRESH_CLICKED'] = 146)] = + 'CASCADE_RULE_REFRESH_CLICKED'; + ProductEventType2[ + (ProductEventType2['CASCADE_IMPORT_RULES_FROM_CURSOR_CLICKED'] = 147) + ] = 'CASCADE_IMPORT_RULES_FROM_CURSOR_CLICKED'; + ProductEventType2[ + (ProductEventType2['WS_IMPORT_CURSOR_RULES_COMMAND_PALETTE'] = 152) + ] = 'WS_IMPORT_CURSOR_RULES_COMMAND_PALETTE'; + ProductEventType2[(ProductEventType2['CASCADE_CHANGES_ACCEPT_ALL'] = 83)] = + 'CASCADE_CHANGES_ACCEPT_ALL'; + ProductEventType2[(ProductEventType2['CASCADE_CHANGES_REJECT_ALL'] = 84)] = + 'CASCADE_CHANGES_REJECT_ALL'; + ProductEventType2[(ProductEventType2['CASCADE_MEMORIES_EDIT'] = 85)] = + 'CASCADE_MEMORIES_EDIT'; + ProductEventType2[(ProductEventType2['CASCADE_MEMORIES_VIEW'] = 86)] = + 'CASCADE_MEMORIES_VIEW'; + ProductEventType2[(ProductEventType2['KEYBOARD_SHORTCUT'] = 136)] = + 'KEYBOARD_SHORTCUT'; + ProductEventType2[(ProductEventType2['CASCADE_INSERT_AT_MENTION'] = 87)] = + 'CASCADE_INSERT_AT_MENTION'; + ProductEventType2[(ProductEventType2['CASCADE_ERROR_STEP'] = 120)] = + 'CASCADE_ERROR_STEP'; + ProductEventType2[ + (ProductEventType2['CASCADE_SUGGESTED_RESPONSES_SUGGESTION_CLICKED'] = 121) + ] = 'CASCADE_SUGGESTED_RESPONSES_SUGGESTION_CLICKED'; + ProductEventType2[(ProductEventType2['CASCADE_PLUGIN_PANEL_OPENED'] = 128)] = + 'CASCADE_PLUGIN_PANEL_OPENED'; + ProductEventType2[(ProductEventType2['CASCADE_PLUGIN_PAGE_OPENED'] = 129)] = + 'CASCADE_PLUGIN_PAGE_OPENED'; + ProductEventType2[(ProductEventType2['CASCADE_PLUGIN_INSTALLED'] = 130)] = + 'CASCADE_PLUGIN_INSTALLED'; + ProductEventType2[(ProductEventType2['CASCADE_PLUGIN_DISABLED'] = 131)] = + 'CASCADE_PLUGIN_DISABLED'; + ProductEventType2[(ProductEventType2['CASCADE_PLUGIN_ENABLED'] = 132)] = + 'CASCADE_PLUGIN_ENABLED'; + ProductEventType2[ + (ProductEventType2['CASCADE_PLUGIN_INSTALLATION_ERROR'] = 133) + ] = 'CASCADE_PLUGIN_INSTALLATION_ERROR'; + ProductEventType2[(ProductEventType2['CASCADE_PLUGIN_TOOL_ENABLED'] = 134)] = + 'CASCADE_PLUGIN_TOOL_ENABLED'; + ProductEventType2[(ProductEventType2['CASCADE_PLUGIN_TOOL_DISABLED'] = 135)] = + 'CASCADE_PLUGIN_TOOL_DISABLED'; + ProductEventType2[(ProductEventType2['CASCADE_CUSTOM_MODEL_EVENT'] = 229)] = + 'CASCADE_CUSTOM_MODEL_EVENT'; + ProductEventType2[(ProductEventType2['WEBSITE_NOT_FOUND_PAGE'] = 88)] = + 'WEBSITE_NOT_FOUND_PAGE'; + ProductEventType2[ + (ProductEventType2['WEBSITE_AUTH_REDIRECT_LONG_WAIT'] = 89) + ] = 'WEBSITE_AUTH_REDIRECT_LONG_WAIT'; + ProductEventType2[(ProductEventType2['WEBSITE_AUTH_REDIRECT_ERROR'] = 90)] = + 'WEBSITE_AUTH_REDIRECT_ERROR'; + ProductEventType2[ + (ProductEventType2['WEBSITE_AUTH_REDIRECT_SUCCESS'] = 112) + ] = 'WEBSITE_AUTH_REDIRECT_SUCCESS'; + ProductEventType2[(ProductEventType2['WEBSITE_PAGE_VISIT'] = 175)] = + 'WEBSITE_PAGE_VISIT'; + ProductEventType2[(ProductEventType2['WEBSITE_SIGNUP_INFO'] = 176)] = + 'WEBSITE_SIGNUP_INFO'; + ProductEventType2[(ProductEventType2['WEBSITE_START_PLAN_CHECKOUT'] = 177)] = + 'WEBSITE_START_PLAN_CHECKOUT'; + ProductEventType2[(ProductEventType2['WEBSITE_START_UPDATE_PAYMENT'] = 202)] = + 'WEBSITE_START_UPDATE_PAYMENT'; + ProductEventType2[(ProductEventType2['WEBSITE_START_VIEW_INVOICES'] = 203)] = + 'WEBSITE_START_VIEW_INVOICES'; + ProductEventType2[ + (ProductEventType2['WEBSITE_UNIVERSITY_LECTURE_VIEW'] = 214) + ] = 'WEBSITE_UNIVERSITY_LECTURE_VIEW'; + ProductEventType2[ + (ProductEventType2['WEBSITE_DISALLOW_ENTERPRISE_LOGIN'] = 224) + ] = 'WEBSITE_DISALLOW_ENTERPRISE_LOGIN'; + ProductEventType2[(ProductEventType2['WEBSITE_SSO_LOGIN_REDIRECT'] = 225)] = + 'WEBSITE_SSO_LOGIN_REDIRECT'; + ProductEventType2[(ProductEventType2['WEBSITE_ATTEMPT_TO_LOGIN'] = 226)] = + 'WEBSITE_ATTEMPT_TO_LOGIN'; + ProductEventType2[(ProductEventType2['WEBSITE_SUCCESSFUL_LOGIN'] = 227)] = + 'WEBSITE_SUCCESSFUL_LOGIN'; + ProductEventType2[(ProductEventType2['WEBSITE_FAILED_LOGIN'] = 228)] = + 'WEBSITE_FAILED_LOGIN'; + ProductEventType2[(ProductEventType2['JB_OPEN_PLAN_INFO'] = 91)] = + 'JB_OPEN_PLAN_INFO'; + ProductEventType2[(ProductEventType2['JB_SNOOZE_PLUGIN'] = 92)] = + 'JB_SNOOZE_PLUGIN'; + ProductEventType2[(ProductEventType2['JB_TOGGLE_PLUGIN_STATUS'] = 93)] = + 'JB_TOGGLE_PLUGIN_STATUS'; + ProductEventType2[(ProductEventType2['JB_SWITCH_CHANNEL'] = 94)] = + 'JB_SWITCH_CHANNEL'; + ProductEventType2[(ProductEventType2['JB_OPEN_SETTINGS'] = 95)] = + 'JB_OPEN_SETTINGS'; + ProductEventType2[(ProductEventType2['JB_PLUGIN_LOG_IN'] = 96)] = + 'JB_PLUGIN_LOG_IN'; + ProductEventType2[(ProductEventType2['JB_PLUGIN_LOG_OUT'] = 97)] = + 'JB_PLUGIN_LOG_OUT'; + ProductEventType2[(ProductEventType2['JB_OPEN_QUICK_REFERENCE'] = 98)] = + 'JB_OPEN_QUICK_REFERENCE'; + ProductEventType2[(ProductEventType2['JB_EDIT_KEYBOARD_SHORTCUTS'] = 99)] = + 'JB_EDIT_KEYBOARD_SHORTCUTS'; + ProductEventType2[(ProductEventType2['JB_CASCADE_BAR_CASCADE_ICON'] = 100)] = + 'JB_CASCADE_BAR_CASCADE_ICON'; + ProductEventType2[(ProductEventType2['JB_CASCADE_BAR_FILE_NAV'] = 101)] = + 'JB_CASCADE_BAR_FILE_NAV'; + ProductEventType2[(ProductEventType2['JB_CASCADE_BAR_HUNK_NAV'] = 102)] = + 'JB_CASCADE_BAR_HUNK_NAV'; + ProductEventType2[(ProductEventType2['JB_CASCADE_BAR_ACCEPT_FILE'] = 103)] = + 'JB_CASCADE_BAR_ACCEPT_FILE'; + ProductEventType2[(ProductEventType2['JB_CASCADE_BAR_REJECT_FILE'] = 104)] = + 'JB_CASCADE_BAR_REJECT_FILE'; + ProductEventType2[(ProductEventType2['JB_INLAY_HUNK_ACCEPT'] = 105)] = + 'JB_INLAY_HUNK_ACCEPT'; + ProductEventType2[(ProductEventType2['JB_INLAY_HUNK_REJECT'] = 106)] = + 'JB_INLAY_HUNK_REJECT'; + ProductEventType2[(ProductEventType2['JB_DIFF_RE_RENDER'] = 107)] = + 'JB_DIFF_RE_RENDER'; + ProductEventType2[(ProductEventType2['JB_ONBOARDING_OPENED'] = 108)] = + 'JB_ONBOARDING_OPENED'; + ProductEventType2[(ProductEventType2['JB_ONBOARDING_COMPLETED'] = 109)] = + 'JB_ONBOARDING_COMPLETED'; + ProductEventType2[(ProductEventType2['JB_ONBOARDING_SKIPPED'] = 110)] = + 'JB_ONBOARDING_SKIPPED'; + ProductEventType2[(ProductEventType2['JB_ONBOARDING_LEARN_MORE'] = 111)] = + 'JB_ONBOARDING_LEARN_MORE'; + ProductEventType2[(ProductEventType2['JB_DIFF_RESOLUTION_ERRORED'] = 116)] = + 'JB_DIFF_RESOLUTION_ERRORED'; + ProductEventType2[ + (ProductEventType2['JB_ACKNOWLEDGE_CODE_EDIT_ERRORED'] = 117) + ] = 'JB_ACKNOWLEDGE_CODE_EDIT_ERRORED'; + ProductEventType2[ + (ProductEventType2['JB_OPEN_SETTINGS_NOTIFICATION'] = 118) + ] = 'JB_OPEN_SETTINGS_NOTIFICATION'; + ProductEventType2[(ProductEventType2['JB_MCP_ADD_SERVER'] = 148)] = + 'JB_MCP_ADD_SERVER'; + ProductEventType2[(ProductEventType2['JB_MCP_SAVE_CONFIG'] = 149)] = + 'JB_MCP_SAVE_CONFIG'; + ProductEventType2[(ProductEventType2['JB_MCP_EXPAND_TOOLS'] = 150)] = + 'JB_MCP_EXPAND_TOOLS'; + ProductEventType2[(ProductEventType2['JB_DISABLE_AUTOGEN_MEMORY'] = 151)] = + 'JB_DISABLE_AUTOGEN_MEMORY'; + ProductEventType2[(ProductEventType2['JB_TOGGLE_AUTOCOMPLETE'] = 154)] = + 'JB_TOGGLE_AUTOCOMPLETE'; + ProductEventType2[(ProductEventType2['JB_LOGIN_MANUAL_AUTH_TOKEN'] = 174)] = + 'JB_LOGIN_MANUAL_AUTH_TOKEN'; + ProductEventType2[(ProductEventType2['JB_AUTO_UPDATED'] = 179)] = + 'JB_AUTO_UPDATED'; + ProductEventType2[(ProductEventType2['JB_DRAG_DROP_FILE'] = 182)] = + 'JB_DRAG_DROP_FILE'; + ProductEventType2[(ProductEventType2['JB_AUTO_OPEN_CHAT_WINDOW'] = 183)] = + 'JB_AUTO_OPEN_CHAT_WINDOW'; + ProductEventType2[ + (ProductEventType2['WS_TERMINAL_INTEGRATION_FORCE_EXIT'] = 155) + ] = 'WS_TERMINAL_INTEGRATION_FORCE_EXIT'; + ProductEventType2[(ProductEventType2['KNOWLEDGE_BASE_ITEM_CREATED'] = 156)] = + 'KNOWLEDGE_BASE_ITEM_CREATED'; + ProductEventType2[(ProductEventType2['KNOWLEDGE_BASE_ITEM_EDITED'] = 157)] = + 'KNOWLEDGE_BASE_ITEM_EDITED'; + ProductEventType2[(ProductEventType2['KNOWLEDGE_BASE_ITEM_DELETED'] = 158)] = + 'KNOWLEDGE_BASE_ITEM_DELETED'; + ProductEventType2[(ProductEventType2['KNOWLEDGE_BASE_ITEM_READ'] = 159)] = + 'KNOWLEDGE_BASE_ITEM_READ'; + ProductEventType2[ + (ProductEventType2['KNOWLEDGE_BASE_CONNECTION_CREATE'] = 160) + ] = 'KNOWLEDGE_BASE_CONNECTION_CREATE'; + ProductEventType2[ + (ProductEventType2['KNOWLEDGE_BASE_CONNECTION_REMOVE'] = 161) + ] = 'KNOWLEDGE_BASE_CONNECTION_REMOVE'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_AUTO_RUN_COMMANDS'] = 162) + ] = 'TEAM_CONFIG_TOGGLE_AUTO_RUN_COMMANDS'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_MCP_SERVERS'] = 163) + ] = 'TEAM_CONFIG_TOGGLE_MCP_SERVERS'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_APP_DEPLOYMENTS'] = 164) + ] = 'TEAM_CONFIG_TOGGLE_APP_DEPLOYMENTS'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_SANDBOX_APP_DEPLOYMENTS'] = 165) + ] = 'TEAM_CONFIG_TOGGLE_SANDBOX_APP_DEPLOYMENTS'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_TEAMS_APP_DEPLOYMENTS'] = 166) + ] = 'TEAM_CONFIG_TOGGLE_TEAMS_APP_DEPLOYMENTS'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_GITHUB_REVIEWS'] = 167) + ] = 'TEAM_CONFIG_TOGGLE_GITHUB_REVIEWS'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_GITHUB_DESCRIPTION_EDITS'] = 168) + ] = 'TEAM_CONFIG_TOGGLE_GITHUB_DESCRIPTION_EDITS'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_PR_REVIEW_GUIDELINES'] = 169) + ] = 'TEAM_CONFIG_TOGGLE_PR_REVIEW_GUIDELINES'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_PR_DESCRIPTION_GUIDELINES'] = 170) + ] = 'TEAM_CONFIG_TOGGLE_PR_DESCRIPTION_GUIDELINES'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_INDIVIDUAL_LEVEL_ANALYTICS'] = 171) + ] = 'TEAM_CONFIG_TOGGLE_INDIVIDUAL_LEVEL_ANALYTICS'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_CONVERSATION_SHARING'] = 172) + ] = 'TEAM_CONFIG_TOGGLE_CONVERSATION_SHARING'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_UPDATE_MCP_SERVERS'] = 178) + ] = 'TEAM_CONFIG_UPDATE_MCP_SERVERS'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_TOGGLE_GITHUB_AUTO_REVIEWS'] = 207) + ] = 'TEAM_CONFIG_TOGGLE_GITHUB_AUTO_REVIEWS'; + ProductEventType2[ + (ProductEventType2['TEAM_CONFIG_UPDATE_TOP_UP_SETTINGS'] = 213) + ] = 'TEAM_CONFIG_UPDATE_TOP_UP_SETTINGS'; + ProductEventType2[(ProductEventType2['BROWSER_OPEN'] = 180)] = 'BROWSER_OPEN'; + ProductEventType2[ + (ProductEventType2['CASCADE_WEB_TOOLS_OPEN_BROWSER_MARKDOWN'] = 181) + ] = 'CASCADE_WEB_TOOLS_OPEN_BROWSER_MARKDOWN'; + ProductEventType2[(ProductEventType2['BROWSER_PAGE_LOAD_SUCCESS'] = 206)] = + 'BROWSER_PAGE_LOAD_SUCCESS'; + ProductEventType2[ + (ProductEventType2['BROWSER_TOOLBAR_INSERT_PAGE_MENTION'] = 208) + ] = 'BROWSER_TOOLBAR_INSERT_PAGE_MENTION'; + ProductEventType2[(ProductEventType2['BROWSER_INSERT_TEXT_CONTENT'] = 215)] = + 'BROWSER_INSERT_TEXT_CONTENT'; + ProductEventType2[(ProductEventType2['BROWSER_INSERT_SCREENSHOT'] = 216)] = + 'BROWSER_INSERT_SCREENSHOT'; + ProductEventType2[(ProductEventType2['BROWSER_INSERT_CODE_BLOCK'] = 217)] = + 'BROWSER_INSERT_CODE_BLOCK'; + ProductEventType2[(ProductEventType2['BROWSER_INSERT_LOG_BLOCK'] = 218)] = + 'BROWSER_INSERT_LOG_BLOCK'; + ProductEventType2[ + (ProductEventType2['BROWSER_INSERT_CONSOLE_OUTPUT'] = 219) + ] = 'BROWSER_INSERT_CONSOLE_OUTPUT'; + ProductEventType2[(ProductEventType2['BROWSER_INSERT_DOM_ELEMENT'] = 220)] = + 'BROWSER_INSERT_DOM_ELEMENT'; + ProductEventType2[ + (ProductEventType2['BROWSER_LAUNCH_FAILURE_DIAGNOSTICS'] = 230) + ] = 'BROWSER_LAUNCH_FAILURE_DIAGNOSTICS'; + ProductEventType2[ + (ProductEventType2['SUPERCOMPLETE_REQUEST_STARTED'] = 195) + ] = 'SUPERCOMPLETE_REQUEST_STARTED'; + ProductEventType2[(ProductEventType2['SUPERCOMPLETE_CACHE_HIT'] = 196)] = + 'SUPERCOMPLETE_CACHE_HIT'; + ProductEventType2[ + (ProductEventType2['SUPERCOMPLETE_ERROR_GETTING_RESPONSE'] = 197) + ] = 'SUPERCOMPLETE_ERROR_GETTING_RESPONSE'; + ProductEventType2[(ProductEventType2['SUPERCOMPLETE_NO_RESPONSE'] = 185)] = + 'SUPERCOMPLETE_NO_RESPONSE'; + ProductEventType2[ + (ProductEventType2['SUPERCOMPLETE_REQUEST_SUCCEEDED'] = 186) + ] = 'SUPERCOMPLETE_REQUEST_SUCCEEDED'; + ProductEventType2[(ProductEventType2['SUPERCOMPLETE_FILTERED'] = 187)] = + 'SUPERCOMPLETE_FILTERED'; + ProductEventType2[(ProductEventType2['TAB_JUMP_REQUEST_STARTED'] = 188)] = + 'TAB_JUMP_REQUEST_STARTED'; + ProductEventType2[(ProductEventType2['TAB_JUMP_CACHE_HIT'] = 189)] = + 'TAB_JUMP_CACHE_HIT'; + ProductEventType2[ + (ProductEventType2['TAB_JUMP_ERROR_GETTING_RESPONSE'] = 190) + ] = 'TAB_JUMP_ERROR_GETTING_RESPONSE'; + ProductEventType2[(ProductEventType2['TAB_JUMP_NO_RESPONSE'] = 191)] = + 'TAB_JUMP_NO_RESPONSE'; + ProductEventType2[(ProductEventType2['TAB_JUMP_PROCESSING_COMPLETE'] = 192)] = + 'TAB_JUMP_PROCESSING_COMPLETE'; + ProductEventType2[(ProductEventType2['TAB_JUMP_FILTERED'] = 193)] = + 'TAB_JUMP_FILTERED'; + ProductEventType2[(ProductEventType2['TAB_JUMP_ERROR_UI_RENDERED'] = 194)] = + 'TAB_JUMP_ERROR_UI_RENDERED'; + ProductEventType2[ + (ProductEventType2['AUTOCOMPLETE_CHAT_NO_RESPONSE'] = 221) + ] = 'AUTOCOMPLETE_CHAT_NO_RESPONSE'; + ProductEventType2[ + (ProductEventType2['AUTOCOMPLETE_CHAT_ERROR_GETTING_RESPONSE'] = 222) + ] = 'AUTOCOMPLETE_CHAT_ERROR_GETTING_RESPONSE'; + ProductEventType2[ + (ProductEventType2['AUTOCOMPLETE_CHAT_REQUEST_ACCEPTED'] = 223) + ] = 'AUTOCOMPLETE_CHAT_REQUEST_ACCEPTED'; +})(ProductEventType || (ProductEventType = {})); +proto3.util.setEnumType( + ProductEventType, + 'exa.codeium_common_pb.ProductEventType', + [ + { no: 0, name: 'EVENT_UNSPECIFIED' }, + { no: 251, name: 'ANTIGRAVITY_EDITOR_READY' }, + { no: 253, name: 'ANTIGRAVITY_EXTENSION_START' }, + { no: 32, name: 'ANTIGRAVITY_EXTENSION_ACTIVATED' }, + { no: 1, name: 'LS_DOWNLOAD_START' }, + { no: 2, name: 'LS_DOWNLOAD_COMPLETE' }, + { no: 5, name: 'LS_DOWNLOAD_FAILURE' }, + { no: 250, name: 'LS_BINARY_STARTUP' }, + { no: 3, name: 'LS_STARTUP' }, + { no: 4, name: 'LS_FAILURE' }, + { no: 6, name: 'AUTOCOMPLETE_ACCEPTED' }, + { no: 7, name: 'AUTOCOMPLETE_ONE_WORD_ACCEPTED' }, + { no: 8, name: 'CHAT_MESSAGE_SENT' }, + { no: 13, name: 'CHAT_MENTION_INSERT' }, + { no: 19, name: 'CHAT_MENTION_MENU_OPEN' }, + { no: 14, name: 'CHAT_OPEN_SETTINGS' }, + { no: 15, name: 'CHAT_OPEN_CONTEXT_SETTINGS' }, + { no: 16, name: 'CHAT_WITH_CODEBASE' }, + { no: 17, name: 'CHAT_NEW_CONVERSATION' }, + { no: 18, name: 'CHAT_CHANGE_MODEL' }, + { no: 34, name: 'CHAT_TOGGLE_FOCUS_INSERT_TEXT' }, + { no: 28, name: 'FUNCTION_REFACTOR' }, + { no: 29, name: 'EXPLAIN_CODE_BLOCK' }, + { no: 30, name: 'FUNCTION_ADD_DOCSTRING' }, + { no: 31, name: 'EXPLAIN_PROBLEM' }, + { no: 9, name: 'COMMAND_BOX_OPENED' }, + { no: 10, name: 'COMMAND_SUBMITTED' }, + { no: 11, name: 'COMMAND_ACCEPTED' }, + { no: 12, name: 'COMMAND_REJECTED' }, + { no: 20, name: 'WS_ONBOARDING_LANDING_PAGE_OPENED' }, + { no: 21, name: 'WS_ONBOARDING_SETUP_PAGE_OPENED' }, + { no: 22, name: 'WS_ONBOARDING_KEYBINDINGS_PAGE_OPENED' }, + { no: 23, name: 'WS_ONBOARDING_MIGRATION_SCOPE_PAGE_OPENED' }, + { no: 24, name: 'WS_ONBOARDING_IMPORT_PAGE_OPENED' }, + { no: 25, name: 'WS_ONBOARDING_AUTH_PAGE_OPENED' }, + { no: 26, name: 'WS_ONBOARDING_AUTH_MANUAL_PAGE_OPENED' }, + { no: 35, name: 'WS_ONBOARDING_CHOOSE_THEME_PAGE_OPENED' }, + { no: 231, name: 'AGY_ONBOARDING_TERMS_OF_USE_PAGE_OPENED' }, + { no: 232, name: 'AGY_ONBOARDING_AGENT_CONFIG_PAGE_OPENED' }, + { no: 233, name: 'AGY_ONBOARDING_USAGE_MODE_PAGE_OPENED' }, + { no: 234, name: 'AGY_ONBOARDING_INSTALL_EXTENSIONS' }, + { no: 27, name: 'WS_ONBOARDING_COMPLETED' }, + { no: 69, name: 'WS_SKIPPED_ONBOARDING' }, + { no: 72, name: 'WS_SETTINGS_PAGE_OPEN' }, + { no: 73, name: 'WS_SETTINGS_PAGE_OPEN_WITH_SETTING_FOCUS' }, + { no: 209, name: 'EMPTY_WORKSPACE_PAGE_OPENED' }, + { no: 210, name: 'EMPTY_WORKSPACE_PAGE_RECENT_FOLDERS_CLICKED' }, + { no: 211, name: 'EMPTY_WORKSPACE_PAGE_OPEN_FOLDER_CLICKED' }, + { no: 212, name: 'EMPTY_WORKSPACE_PAGE_GENERATE_PROJECT_CLICKED' }, + { no: 33, name: 'PROVIDE_FEEDBACK' }, + { no: 36, name: 'CASCADE_MESSAGE_SENT' }, + { no: 38, name: 'WS_OPEN_CASCADE_MEMORIES_PANEL' }, + { no: 41, name: 'PROVIDE_MESSAGE_FEEDBACK' }, + { no: 42, name: 'CASCADE_MEMORY_DELETED' }, + { no: 43, name: 'CASCADE_STEP_COMPLETED' }, + { no: 44, name: 'ACKNOWLEDGE_CASCADE_CODE_EDIT' }, + { no: 45, name: 'CASCADE_WEB_TOOLS_OPEN_READ_URL_MARKDOWN' }, + { no: 46, name: 'CASCADE_WEB_TOOLS_OPEN_CHUNK_MARKDOWN' }, + { no: 64, name: 'CASCADE_MCP_SERVER_INIT' }, + { no: 113, name: 'CASCADE_KNOWLEDGE_BASE_ITEM_OPENED' }, + { no: 119, name: 'CASCADE_VIEW_LOADED' }, + { no: 173, name: 'CASCADE_CONTEXT_SCOPE_ITEM_ATTACHED' }, + { no: 65, name: 'CASCADE_CLICK_EVENT' }, + { no: 67, name: 'CASCADE_IMPRESSION_EVENT' }, + { no: 37, name: 'OPEN_CHANGELOG' }, + { no: 39, name: 'CURSOR_DETECTED' }, + { no: 40, name: 'VSCODE_DETECTED' }, + { no: 153, name: 'JETBRAINS_DETECTED' }, + { no: 47, name: 'CROSS_SELL_EXTENSION_DOWNLOAD_ANTIGRAVITY_CLICK' }, + { + no: 48, + name: 'CROSS_SELL_EXTENSION_DOWNLOAD_ANTIGRAVITY_NUDGE_IMPRESSION', + }, + { no: 49, name: 'WS_PROBLEMS_TAB_SEND_ALL_TO_CASCADE' }, + { no: 50, name: 'WS_PROBLEMS_TAB_SEND_ALL_IN_FILE_TO_CASCADE' }, + { no: 51, name: 'WS_CASCADE_BAR_FILE_NAV' }, + { no: 52, name: 'WS_CASCADE_BAR_HUNK_NAV' }, + { no: 53, name: 'WS_CASCADE_BAR_ACCEPT_FILE' }, + { no: 54, name: 'WS_CASCADE_BAR_REJECT_FILE' }, + { no: 55, name: 'WS_CUSTOM_APP_ICON_MODAL_OPEN' }, + { no: 56, name: 'WS_CUSTOM_APP_ICON_SELECT_CLASSIC' }, + { no: 57, name: 'WS_CUSTOM_APP_ICON_SELECT_CLASSIC_LIGHT' }, + { no: 58, name: 'WS_CUSTOM_APP_ICON_SELECT_RETRO' }, + { no: 59, name: 'WS_CUSTOM_APP_ICON_SELECT_BLUEPRINT' }, + { no: 60, name: 'WS_CUSTOM_APP_ICON_SELECT_HAND_DRAWN' }, + { no: 61, name: 'WS_CUSTOM_APP_ICON_SELECT_SUNSET' }, + { no: 66, name: 'WS_CUSTOM_APP_ICON_SELECT_VALENTINE' }, + { no: 82, name: 'WS_CUSTOM_APP_ICON_SELECT_PIXEL_SURF' }, + { no: 63, name: 'ENTERED_MCP_TOOLBAR_TAB' }, + { no: 62, name: 'CLICKED_TO_CONFIGURE_MCP' }, + { no: 68, name: 'WS_SETTINGS_UPDATED' }, + { no: 70, name: 'BROWSER_PREVIEW_DOM_ELEMENT' }, + { no: 71, name: 'BROWSER_PREVIEW_CONSOLE_OUTPUT' }, + { no: 74, name: 'WS_SETTINGS_CHANGED_BY_USER' }, + { no: 75, name: 'WS_GENERATE_COMMIT_MESSAGE_CLICKED' }, + { no: 76, name: 'WS_GENERATE_COMMIT_MESSAGE_ERRORED' }, + { no: 77, name: 'WS_CLICKED_COMMIT_FROM_SCM_PANEL' }, + { no: 79, name: 'WS_CANCELED_GENERATE_COMMIT_MESSAGE' }, + { no: 78, name: 'USING_DEV_EXTENSION' }, + { no: 80, name: 'WS_APP_DEPLOYMENT_CREATE_PROJECT' }, + { no: 81, name: 'WS_APP_DEPLOYMENT_DEPLOY_PROJECT' }, + { no: 114, name: 'CASCADE_OPEN_ACTIVE_CONVERSATION_DROPDOWN' }, + { no: 115, name: 'CASCADE_SELECT_ACTIVE_CONVERSATION_ON_DROPDOWN' }, + { no: 122, name: 'CASCADE_NAVIGATE_ACTIVE_CONVERSATION_ON_DROPDOWN' }, + { no: 123, name: 'CASCADE_SNOOZE_CONVERSATION_ON_DROPDOWN' }, + { no: 124, name: 'CASCADE_TOGGLE_NOTIFICATION_ON_DROPDOWN' }, + { no: 125, name: 'CASCADE_SELECT_NOTIFICATION_ON_DROPDOWN' }, + { no: 126, name: 'CASCADE_NAVIGATE_NOTIFICATION_ON_DROPDOWN' }, + { no: 127, name: 'CASCADE_DISMISS_NOTIFICATION_ON_DROPDOWN' }, + { no: 137, name: 'CASCADE_TRAJECTORY_SHARE_COPY_LINK' }, + { no: 138, name: 'CASCADE_TRAJECTORY_SHARE_CREATE_LINK' }, + { no: 139, name: 'CASCADE_CUSTOMIZATIONS_TAB_CHANGE' }, + { no: 140, name: 'CASCADE_WORKFLOW_OPEN' }, + { no: 141, name: 'CASCADE_NEW_WORKFLOW_CLICKED' }, + { no: 184, name: 'CASCADE_NEW_GLOBAL_WORKFLOW_CLICKED' }, + { no: 142, name: 'CASCADE_WORKFLOW_REFRESH_CLICKED' }, + { no: 143, name: 'CASCADE_RULE_OPEN' }, + { no: 144, name: 'CASCADE_NEW_RULE_CLICKED' }, + { no: 145, name: 'CASCADE_NEW_GLOBAL_RULE_CLICKED' }, + { no: 146, name: 'CASCADE_RULE_REFRESH_CLICKED' }, + { no: 147, name: 'CASCADE_IMPORT_RULES_FROM_CURSOR_CLICKED' }, + { no: 152, name: 'WS_IMPORT_CURSOR_RULES_COMMAND_PALETTE' }, + { no: 83, name: 'CASCADE_CHANGES_ACCEPT_ALL' }, + { no: 84, name: 'CASCADE_CHANGES_REJECT_ALL' }, + { no: 85, name: 'CASCADE_MEMORIES_EDIT' }, + { no: 86, name: 'CASCADE_MEMORIES_VIEW' }, + { no: 136, name: 'KEYBOARD_SHORTCUT' }, + { no: 87, name: 'CASCADE_INSERT_AT_MENTION' }, + { no: 120, name: 'CASCADE_ERROR_STEP' }, + { no: 121, name: 'CASCADE_SUGGESTED_RESPONSES_SUGGESTION_CLICKED' }, + { no: 128, name: 'CASCADE_PLUGIN_PANEL_OPENED' }, + { no: 129, name: 'CASCADE_PLUGIN_PAGE_OPENED' }, + { no: 130, name: 'CASCADE_PLUGIN_INSTALLED' }, + { no: 131, name: 'CASCADE_PLUGIN_DISABLED' }, + { no: 132, name: 'CASCADE_PLUGIN_ENABLED' }, + { no: 133, name: 'CASCADE_PLUGIN_INSTALLATION_ERROR' }, + { no: 134, name: 'CASCADE_PLUGIN_TOOL_ENABLED' }, + { no: 135, name: 'CASCADE_PLUGIN_TOOL_DISABLED' }, + { no: 229, name: 'CASCADE_CUSTOM_MODEL_EVENT' }, + { no: 88, name: 'WEBSITE_NOT_FOUND_PAGE' }, + { no: 89, name: 'WEBSITE_AUTH_REDIRECT_LONG_WAIT' }, + { no: 90, name: 'WEBSITE_AUTH_REDIRECT_ERROR' }, + { no: 112, name: 'WEBSITE_AUTH_REDIRECT_SUCCESS' }, + { no: 175, name: 'WEBSITE_PAGE_VISIT' }, + { no: 176, name: 'WEBSITE_SIGNUP_INFO' }, + { no: 177, name: 'WEBSITE_START_PLAN_CHECKOUT' }, + { no: 202, name: 'WEBSITE_START_UPDATE_PAYMENT' }, + { no: 203, name: 'WEBSITE_START_VIEW_INVOICES' }, + { no: 214, name: 'WEBSITE_UNIVERSITY_LECTURE_VIEW' }, + { no: 224, name: 'WEBSITE_DISALLOW_ENTERPRISE_LOGIN' }, + { no: 225, name: 'WEBSITE_SSO_LOGIN_REDIRECT' }, + { no: 226, name: 'WEBSITE_ATTEMPT_TO_LOGIN' }, + { no: 227, name: 'WEBSITE_SUCCESSFUL_LOGIN' }, + { no: 228, name: 'WEBSITE_FAILED_LOGIN' }, + { no: 91, name: 'JB_OPEN_PLAN_INFO' }, + { no: 92, name: 'JB_SNOOZE_PLUGIN' }, + { no: 93, name: 'JB_TOGGLE_PLUGIN_STATUS' }, + { no: 94, name: 'JB_SWITCH_CHANNEL' }, + { no: 95, name: 'JB_OPEN_SETTINGS' }, + { no: 96, name: 'JB_PLUGIN_LOG_IN' }, + { no: 97, name: 'JB_PLUGIN_LOG_OUT' }, + { no: 98, name: 'JB_OPEN_QUICK_REFERENCE' }, + { no: 99, name: 'JB_EDIT_KEYBOARD_SHORTCUTS' }, + { no: 100, name: 'JB_CASCADE_BAR_CASCADE_ICON' }, + { no: 101, name: 'JB_CASCADE_BAR_FILE_NAV' }, + { no: 102, name: 'JB_CASCADE_BAR_HUNK_NAV' }, + { no: 103, name: 'JB_CASCADE_BAR_ACCEPT_FILE' }, + { no: 104, name: 'JB_CASCADE_BAR_REJECT_FILE' }, + { no: 105, name: 'JB_INLAY_HUNK_ACCEPT' }, + { no: 106, name: 'JB_INLAY_HUNK_REJECT' }, + { no: 107, name: 'JB_DIFF_RE_RENDER' }, + { no: 108, name: 'JB_ONBOARDING_OPENED' }, + { no: 109, name: 'JB_ONBOARDING_COMPLETED' }, + { no: 110, name: 'JB_ONBOARDING_SKIPPED' }, + { no: 111, name: 'JB_ONBOARDING_LEARN_MORE' }, + { no: 116, name: 'JB_DIFF_RESOLUTION_ERRORED' }, + { no: 117, name: 'JB_ACKNOWLEDGE_CODE_EDIT_ERRORED' }, + { no: 118, name: 'JB_OPEN_SETTINGS_NOTIFICATION' }, + { no: 148, name: 'JB_MCP_ADD_SERVER' }, + { no: 149, name: 'JB_MCP_SAVE_CONFIG' }, + { no: 150, name: 'JB_MCP_EXPAND_TOOLS' }, + { no: 151, name: 'JB_DISABLE_AUTOGEN_MEMORY' }, + { no: 154, name: 'JB_TOGGLE_AUTOCOMPLETE' }, + { no: 174, name: 'JB_LOGIN_MANUAL_AUTH_TOKEN' }, + { no: 179, name: 'JB_AUTO_UPDATED' }, + { no: 182, name: 'JB_DRAG_DROP_FILE' }, + { no: 183, name: 'JB_AUTO_OPEN_CHAT_WINDOW' }, + { no: 155, name: 'WS_TERMINAL_INTEGRATION_FORCE_EXIT' }, + { no: 156, name: 'KNOWLEDGE_BASE_ITEM_CREATED' }, + { no: 157, name: 'KNOWLEDGE_BASE_ITEM_EDITED' }, + { no: 158, name: 'KNOWLEDGE_BASE_ITEM_DELETED' }, + { no: 159, name: 'KNOWLEDGE_BASE_ITEM_READ' }, + { no: 160, name: 'KNOWLEDGE_BASE_CONNECTION_CREATE' }, + { no: 161, name: 'KNOWLEDGE_BASE_CONNECTION_REMOVE' }, + { no: 162, name: 'TEAM_CONFIG_TOGGLE_AUTO_RUN_COMMANDS' }, + { no: 163, name: 'TEAM_CONFIG_TOGGLE_MCP_SERVERS' }, + { no: 164, name: 'TEAM_CONFIG_TOGGLE_APP_DEPLOYMENTS' }, + { no: 165, name: 'TEAM_CONFIG_TOGGLE_SANDBOX_APP_DEPLOYMENTS' }, + { no: 166, name: 'TEAM_CONFIG_TOGGLE_TEAMS_APP_DEPLOYMENTS' }, + { no: 167, name: 'TEAM_CONFIG_TOGGLE_GITHUB_REVIEWS' }, + { no: 168, name: 'TEAM_CONFIG_TOGGLE_GITHUB_DESCRIPTION_EDITS' }, + { no: 169, name: 'TEAM_CONFIG_TOGGLE_PR_REVIEW_GUIDELINES' }, + { no: 170, name: 'TEAM_CONFIG_TOGGLE_PR_DESCRIPTION_GUIDELINES' }, + { no: 171, name: 'TEAM_CONFIG_TOGGLE_INDIVIDUAL_LEVEL_ANALYTICS' }, + { no: 172, name: 'TEAM_CONFIG_TOGGLE_CONVERSATION_SHARING' }, + { no: 178, name: 'TEAM_CONFIG_UPDATE_MCP_SERVERS' }, + { no: 207, name: 'TEAM_CONFIG_TOGGLE_GITHUB_AUTO_REVIEWS' }, + { no: 213, name: 'TEAM_CONFIG_UPDATE_TOP_UP_SETTINGS' }, + { no: 180, name: 'BROWSER_OPEN' }, + { no: 181, name: 'CASCADE_WEB_TOOLS_OPEN_BROWSER_MARKDOWN' }, + { no: 206, name: 'BROWSER_PAGE_LOAD_SUCCESS' }, + { no: 208, name: 'BROWSER_TOOLBAR_INSERT_PAGE_MENTION' }, + { no: 215, name: 'BROWSER_INSERT_TEXT_CONTENT' }, + { no: 216, name: 'BROWSER_INSERT_SCREENSHOT' }, + { no: 217, name: 'BROWSER_INSERT_CODE_BLOCK' }, + { no: 218, name: 'BROWSER_INSERT_LOG_BLOCK' }, + { no: 219, name: 'BROWSER_INSERT_CONSOLE_OUTPUT' }, + { no: 220, name: 'BROWSER_INSERT_DOM_ELEMENT' }, + { no: 230, name: 'BROWSER_LAUNCH_FAILURE_DIAGNOSTICS' }, + { no: 195, name: 'SUPERCOMPLETE_REQUEST_STARTED' }, + { no: 196, name: 'SUPERCOMPLETE_CACHE_HIT' }, + { no: 197, name: 'SUPERCOMPLETE_ERROR_GETTING_RESPONSE' }, + { no: 185, name: 'SUPERCOMPLETE_NO_RESPONSE' }, + { no: 186, name: 'SUPERCOMPLETE_REQUEST_SUCCEEDED' }, + { no: 187, name: 'SUPERCOMPLETE_FILTERED' }, + { no: 188, name: 'TAB_JUMP_REQUEST_STARTED' }, + { no: 189, name: 'TAB_JUMP_CACHE_HIT' }, + { no: 190, name: 'TAB_JUMP_ERROR_GETTING_RESPONSE' }, + { no: 191, name: 'TAB_JUMP_NO_RESPONSE' }, + { no: 192, name: 'TAB_JUMP_PROCESSING_COMPLETE' }, + { no: 193, name: 'TAB_JUMP_FILTERED' }, + { no: 194, name: 'TAB_JUMP_ERROR_UI_RENDERED' }, + { no: 221, name: 'AUTOCOMPLETE_CHAT_NO_RESPONSE' }, + { no: 222, name: 'AUTOCOMPLETE_CHAT_ERROR_GETTING_RESPONSE' }, + { no: 223, name: 'AUTOCOMPLETE_CHAT_REQUEST_ACCEPTED' }, + ], +); +var IndexChoice; +(function (IndexChoice2) { + IndexChoice2[(IndexChoice2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + IndexChoice2[(IndexChoice2['GITHUB_BASE'] = 1)] = 'GITHUB_BASE'; + IndexChoice2[(IndexChoice2['SLACK_BASE'] = 2)] = 'SLACK_BASE'; + IndexChoice2[(IndexChoice2['SLACK_AGGREGATE'] = 3)] = 'SLACK_AGGREGATE'; + IndexChoice2[(IndexChoice2['GOOGLE_DRIVE_BASE'] = 4)] = 'GOOGLE_DRIVE_BASE'; + IndexChoice2[(IndexChoice2['JIRA_BASE'] = 5)] = 'JIRA_BASE'; + IndexChoice2[(IndexChoice2['SCM'] = 6)] = 'SCM'; +})(IndexChoice || (IndexChoice = {})); +proto3.util.setEnumType(IndexChoice, 'exa.codeium_common_pb.IndexChoice', [ + { no: 0, name: 'INDEX_CHOICE_UNSPECIFIED' }, + { no: 1, name: 'INDEX_CHOICE_GITHUB_BASE' }, + { no: 2, name: 'INDEX_CHOICE_SLACK_BASE' }, + { no: 3, name: 'INDEX_CHOICE_SLACK_AGGREGATE' }, + { no: 4, name: 'INDEX_CHOICE_GOOGLE_DRIVE_BASE' }, + { no: 5, name: 'INDEX_CHOICE_JIRA_BASE' }, + { no: 6, name: 'INDEX_CHOICE_SCM' }, +]); +var MarkdownNodeType; +(function (MarkdownNodeType2) { + MarkdownNodeType2[(MarkdownNodeType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + MarkdownNodeType2[(MarkdownNodeType2['HEADER_1'] = 1)] = 'HEADER_1'; + MarkdownNodeType2[(MarkdownNodeType2['HEADER_2'] = 2)] = 'HEADER_2'; + MarkdownNodeType2[(MarkdownNodeType2['HEADER_3'] = 3)] = 'HEADER_3'; + MarkdownNodeType2[(MarkdownNodeType2['HEADER_4'] = 4)] = 'HEADER_4'; + MarkdownNodeType2[(MarkdownNodeType2['HEADER_5'] = 5)] = 'HEADER_5'; + MarkdownNodeType2[(MarkdownNodeType2['HEADER_6'] = 6)] = 'HEADER_6'; +})(MarkdownNodeType || (MarkdownNodeType = {})); +proto3.util.setEnumType( + MarkdownNodeType, + 'exa.codeium_common_pb.MarkdownNodeType', + [ + { no: 0, name: 'MARKDOWN_NODE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'MARKDOWN_NODE_TYPE_HEADER_1' }, + { no: 2, name: 'MARKDOWN_NODE_TYPE_HEADER_2' }, + { no: 3, name: 'MARKDOWN_NODE_TYPE_HEADER_3' }, + { no: 4, name: 'MARKDOWN_NODE_TYPE_HEADER_4' }, + { no: 5, name: 'MARKDOWN_NODE_TYPE_HEADER_5' }, + { no: 6, name: 'MARKDOWN_NODE_TYPE_HEADER_6' }, + ], +); +var TerminalShellCommandSource; +(function (TerminalShellCommandSource2) { + TerminalShellCommandSource2[ + (TerminalShellCommandSource2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + TerminalShellCommandSource2[(TerminalShellCommandSource2['USER'] = 1)] = + 'USER'; + TerminalShellCommandSource2[(TerminalShellCommandSource2['CASCADE'] = 2)] = + 'CASCADE'; +})(TerminalShellCommandSource || (TerminalShellCommandSource = {})); +proto3.util.setEnumType( + TerminalShellCommandSource, + 'exa.codeium_common_pb.TerminalShellCommandSource', + [ + { no: 0, name: 'TERMINAL_SHELL_COMMAND_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'TERMINAL_SHELL_COMMAND_SOURCE_USER' }, + { no: 2, name: 'TERMINAL_SHELL_COMMAND_SOURCE_CASCADE' }, + ], +); +var TerminalShellCommandStatus; +(function (TerminalShellCommandStatus2) { + TerminalShellCommandStatus2[ + (TerminalShellCommandStatus2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + TerminalShellCommandStatus2[(TerminalShellCommandStatus2['RUNNING'] = 1)] = + 'RUNNING'; + TerminalShellCommandStatus2[(TerminalShellCommandStatus2['COMPLETED'] = 2)] = + 'COMPLETED'; +})(TerminalShellCommandStatus || (TerminalShellCommandStatus = {})); +proto3.util.setEnumType( + TerminalShellCommandStatus, + 'exa.codeium_common_pb.TerminalShellCommandStatus', + [ + { no: 0, name: 'TERMINAL_SHELL_COMMAND_STATUS_UNSPECIFIED' }, + { no: 1, name: 'TERMINAL_SHELL_COMMAND_STATUS_RUNNING' }, + { no: 2, name: 'TERMINAL_SHELL_COMMAND_STATUS_COMPLETED' }, + ], +); +var DeploymentBuildStatus; +(function (DeploymentBuildStatus2) { + DeploymentBuildStatus2[(DeploymentBuildStatus2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + DeploymentBuildStatus2[(DeploymentBuildStatus2['QUEUED'] = 1)] = 'QUEUED'; + DeploymentBuildStatus2[(DeploymentBuildStatus2['INITIALIZING'] = 2)] = + 'INITIALIZING'; + DeploymentBuildStatus2[(DeploymentBuildStatus2['BUILDING'] = 3)] = 'BUILDING'; + DeploymentBuildStatus2[(DeploymentBuildStatus2['ERROR'] = 4)] = 'ERROR'; + DeploymentBuildStatus2[(DeploymentBuildStatus2['READY'] = 5)] = 'READY'; + DeploymentBuildStatus2[(DeploymentBuildStatus2['CANCELED'] = 6)] = 'CANCELED'; +})(DeploymentBuildStatus || (DeploymentBuildStatus = {})); +proto3.util.setEnumType( + DeploymentBuildStatus, + 'exa.codeium_common_pb.DeploymentBuildStatus', + [ + { no: 0, name: 'DEPLOYMENT_BUILD_STATUS_UNSPECIFIED' }, + { no: 1, name: 'DEPLOYMENT_BUILD_STATUS_QUEUED' }, + { no: 2, name: 'DEPLOYMENT_BUILD_STATUS_INITIALIZING' }, + { no: 3, name: 'DEPLOYMENT_BUILD_STATUS_BUILDING' }, + { no: 4, name: 'DEPLOYMENT_BUILD_STATUS_ERROR' }, + { no: 5, name: 'DEPLOYMENT_BUILD_STATUS_READY' }, + { no: 6, name: 'DEPLOYMENT_BUILD_STATUS_CANCELED' }, + ], +); +var DeploymentProvider; +(function (DeploymentProvider2) { + DeploymentProvider2[(DeploymentProvider2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + DeploymentProvider2[(DeploymentProvider2['VERCEL'] = 1)] = 'VERCEL'; + DeploymentProvider2[(DeploymentProvider2['NETLIFY'] = 2)] = 'NETLIFY'; + DeploymentProvider2[(DeploymentProvider2['CLOUDFLARE'] = 3)] = 'CLOUDFLARE'; +})(DeploymentProvider || (DeploymentProvider = {})); +proto3.util.setEnumType( + DeploymentProvider, + 'exa.codeium_common_pb.DeploymentProvider', + [ + { no: 0, name: 'DEPLOYMENT_PROVIDER_UNSPECIFIED' }, + { no: 1, name: 'DEPLOYMENT_PROVIDER_VERCEL' }, + { no: 2, name: 'DEPLOYMENT_PROVIDER_NETLIFY' }, + { no: 3, name: 'DEPLOYMENT_PROVIDER_CLOUDFLARE' }, + ], +); +var ValidationStatus; +(function (ValidationStatus2) { + ValidationStatus2[(ValidationStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ValidationStatus2[(ValidationStatus2['AVAILABLE'] = 1)] = 'AVAILABLE'; + ValidationStatus2[(ValidationStatus2['IN_USE'] = 2)] = 'IN_USE'; + ValidationStatus2[(ValidationStatus2['TAKEN'] = 3)] = 'TAKEN'; + ValidationStatus2[(ValidationStatus2['INVALID'] = 4)] = 'INVALID'; +})(ValidationStatus || (ValidationStatus = {})); +proto3.util.setEnumType( + ValidationStatus, + 'exa.codeium_common_pb.ValidationStatus', + [ + { no: 0, name: 'VALIDATION_STATUS_UNSPECIFIED' }, + { no: 1, name: 'VALIDATION_STATUS_AVAILABLE' }, + { no: 2, name: 'VALIDATION_STATUS_IN_USE' }, + { no: 3, name: 'VALIDATION_STATUS_TAKEN' }, + { no: 4, name: 'VALIDATION_STATUS_INVALID' }, + ], +); +var PromptTemplaterType; +(function (PromptTemplaterType2) { + PromptTemplaterType2[(PromptTemplaterType2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + PromptTemplaterType2[(PromptTemplaterType2['LLAMA_2'] = 1)] = 'LLAMA_2'; + PromptTemplaterType2[(PromptTemplaterType2['LLAMA_3'] = 2)] = 'LLAMA_3'; + PromptTemplaterType2[(PromptTemplaterType2['CHATML'] = 3)] = 'CHATML'; + PromptTemplaterType2[(PromptTemplaterType2['CHAT_TRANSCRIPT'] = 4)] = + 'CHAT_TRANSCRIPT'; + PromptTemplaterType2[(PromptTemplaterType2['DEEPSEEK_V2'] = 5)] = + 'DEEPSEEK_V2'; + PromptTemplaterType2[(PromptTemplaterType2['DEEPSEEK_V3'] = 6)] = + 'DEEPSEEK_V3'; +})(PromptTemplaterType || (PromptTemplaterType = {})); +proto3.util.setEnumType( + PromptTemplaterType, + 'exa.codeium_common_pb.PromptTemplaterType', + [ + { no: 0, name: 'PROMPT_TEMPLATER_TYPE_UNSPECIFIED' }, + { no: 1, name: 'PROMPT_TEMPLATER_TYPE_LLAMA_2' }, + { no: 2, name: 'PROMPT_TEMPLATER_TYPE_LLAMA_3' }, + { no: 3, name: 'PROMPT_TEMPLATER_TYPE_CHATML' }, + { no: 4, name: 'PROMPT_TEMPLATER_TYPE_CHAT_TRANSCRIPT' }, + { no: 5, name: 'PROMPT_TEMPLATER_TYPE_DEEPSEEK_V2' }, + { no: 6, name: 'PROMPT_TEMPLATER_TYPE_DEEPSEEK_V3' }, + ], +); +var ToolFormatterType; +(function (ToolFormatterType2) { + ToolFormatterType2[(ToolFormatterType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ToolFormatterType2[(ToolFormatterType2['LLAMA_3'] = 1)] = 'LLAMA_3'; + ToolFormatterType2[(ToolFormatterType2['HERMES'] = 2)] = 'HERMES'; + ToolFormatterType2[(ToolFormatterType2['XML'] = 3)] = 'XML'; + ToolFormatterType2[(ToolFormatterType2['CHAT_TRANSCRIPT'] = 4)] = + 'CHAT_TRANSCRIPT'; + ToolFormatterType2[(ToolFormatterType2['NONE'] = 5)] = 'NONE'; +})(ToolFormatterType || (ToolFormatterType = {})); +proto3.util.setEnumType( + ToolFormatterType, + 'exa.codeium_common_pb.ToolFormatterType', + [ + { no: 0, name: 'TOOL_FORMATTER_TYPE_UNSPECIFIED' }, + { no: 1, name: 'TOOL_FORMATTER_TYPE_LLAMA_3' }, + { no: 2, name: 'TOOL_FORMATTER_TYPE_HERMES' }, + { no: 3, name: 'TOOL_FORMATTER_TYPE_XML' }, + { no: 4, name: 'TOOL_FORMATTER_TYPE_CHAT_TRANSCRIPT' }, + { no: 5, name: 'TOOL_FORMATTER_TYPE_NONE' }, + ], +); +var BrowserInstallationStatus; +(function (BrowserInstallationStatus2) { + BrowserInstallationStatus2[(BrowserInstallationStatus2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + BrowserInstallationStatus2[ + (BrowserInstallationStatus2['NOT_INSTALLED'] = 1) + ] = 'NOT_INSTALLED'; + BrowserInstallationStatus2[(BrowserInstallationStatus2['IN_PROGRESS'] = 2)] = + 'IN_PROGRESS'; + BrowserInstallationStatus2[(BrowserInstallationStatus2['COMPLETE'] = 3)] = + 'COMPLETE'; + BrowserInstallationStatus2[(BrowserInstallationStatus2['ERROR'] = 4)] = + 'ERROR'; +})(BrowserInstallationStatus || (BrowserInstallationStatus = {})); +proto3.util.setEnumType( + BrowserInstallationStatus, + 'exa.codeium_common_pb.BrowserInstallationStatus', + [ + { no: 0, name: 'BROWSER_INSTALLATION_STATUS_UNSPECIFIED' }, + { no: 1, name: 'BROWSER_INSTALLATION_STATUS_NOT_INSTALLED' }, + { no: 2, name: 'BROWSER_INSTALLATION_STATUS_IN_PROGRESS' }, + { no: 3, name: 'BROWSER_INSTALLATION_STATUS_COMPLETE' }, + { no: 4, name: 'BROWSER_INSTALLATION_STATUS_ERROR' }, + ], +); +var BetterDirection; +(function (BetterDirection2) { + BetterDirection2[(BetterDirection2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + BetterDirection2[(BetterDirection2['LOWER'] = 1)] = 'LOWER'; + BetterDirection2[(BetterDirection2['HIGHER'] = 2)] = 'HIGHER'; +})(BetterDirection || (BetterDirection = {})); +proto3.util.setEnumType( + BetterDirection, + 'exa.codeium_common_pb.BetterDirection', + [ + { no: 0, name: 'BETTER_DIRECTION_UNSPECIFIED' }, + { no: 1, name: 'BETTER_DIRECTION_LOWER' }, + { no: 2, name: 'BETTER_DIRECTION_HIGHER' }, + ], +); +var MetricsScope; +(function (MetricsScope2) { + MetricsScope2[(MetricsScope2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + MetricsScope2[(MetricsScope2['EXECUTION_SEGMENT'] = 1)] = 'EXECUTION_SEGMENT'; + MetricsScope2[(MetricsScope2['TRAJECTORY'] = 2)] = 'TRAJECTORY'; +})(MetricsScope || (MetricsScope = {})); +proto3.util.setEnumType(MetricsScope, 'exa.codeium_common_pb.MetricsScope', [ + { no: 0, name: 'METRICS_SCOPE_UNSPECIFIED' }, + { no: 1, name: 'METRICS_SCOPE_EXECUTION_SEGMENT' }, + { no: 2, name: 'METRICS_SCOPE_TRAJECTORY' }, +]); +var TrajectoryType; +(function (TrajectoryType2) { + TrajectoryType2[(TrajectoryType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + TrajectoryType2[(TrajectoryType2['CASCADE'] = 1)] = 'CASCADE'; + TrajectoryType2[(TrajectoryType2['MAINLINE_TRAJECTORY'] = 2)] = + 'MAINLINE_TRAJECTORY'; +})(TrajectoryType || (TrajectoryType = {})); +proto3.util.setEnumType( + TrajectoryType, + 'exa.codeium_common_pb.TrajectoryType', + [ + { no: 0, name: 'TRAJECTORY_TYPE_UNSPECIFIED' }, + { no: 1, name: 'TRAJECTORY_TYPE_CASCADE' }, + { no: 2, name: 'TRAJECTORY_TYPE_MAINLINE_TRAJECTORY' }, + ], +); +var RefreshCustomizationType; +(function (RefreshCustomizationType2) { + RefreshCustomizationType2[(RefreshCustomizationType2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + RefreshCustomizationType2[(RefreshCustomizationType2['RULE'] = 1)] = 'RULE'; + RefreshCustomizationType2[(RefreshCustomizationType2['WORKFLOW'] = 2)] = + 'WORKFLOW'; + RefreshCustomizationType2[(RefreshCustomizationType2['SKILL'] = 3)] = 'SKILL'; +})(RefreshCustomizationType || (RefreshCustomizationType = {})); +proto3.util.setEnumType( + RefreshCustomizationType, + 'exa.codeium_common_pb.RefreshCustomizationType', + [ + { no: 0, name: 'REFRESH_CUSTOMIZATION_TYPE_UNSPECIFIED' }, + { no: 1, name: 'REFRESH_CUSTOMIZATION_TYPE_RULE' }, + { no: 2, name: 'REFRESH_CUSTOMIZATION_TYPE_WORKFLOW' }, + { no: 3, name: 'REFRESH_CUSTOMIZATION_TYPE_SKILL' }, + ], +); +var ThirdPartyWebSearchProvider; +(function (ThirdPartyWebSearchProvider2) { + ThirdPartyWebSearchProvider2[ + (ThirdPartyWebSearchProvider2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + ThirdPartyWebSearchProvider2[(ThirdPartyWebSearchProvider2['GEMINI'] = 2)] = + 'GEMINI'; +})(ThirdPartyWebSearchProvider || (ThirdPartyWebSearchProvider = {})); +proto3.util.setEnumType( + ThirdPartyWebSearchProvider, + 'exa.codeium_common_pb.ThirdPartyWebSearchProvider', + [ + { no: 0, name: 'THIRD_PARTY_WEB_SEARCH_PROVIDER_UNSPECIFIED' }, + { no: 2, name: 'THIRD_PARTY_WEB_SEARCH_PROVIDER_GEMINI' }, + ], +); +var ThirdPartyWebSearchModel; +(function (ThirdPartyWebSearchModel2) { + ThirdPartyWebSearchModel2[(ThirdPartyWebSearchModel2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + ThirdPartyWebSearchModel2[(ThirdPartyWebSearchModel2['O3'] = 1)] = 'O3'; + ThirdPartyWebSearchModel2[(ThirdPartyWebSearchModel2['GPT_4_1'] = 2)] = + 'GPT_4_1'; + ThirdPartyWebSearchModel2[(ThirdPartyWebSearchModel2['O4_MINI'] = 3)] = + 'O4_MINI'; +})(ThirdPartyWebSearchModel || (ThirdPartyWebSearchModel = {})); +proto3.util.setEnumType( + ThirdPartyWebSearchModel, + 'exa.codeium_common_pb.ThirdPartyWebSearchModel', + [ + { no: 0, name: 'THIRD_PARTY_WEB_SEARCH_MODEL_UNSPECIFIED' }, + { no: 1, name: 'THIRD_PARTY_WEB_SEARCH_MODEL_O3' }, + { no: 2, name: 'THIRD_PARTY_WEB_SEARCH_MODEL_GPT_4_1' }, + { no: 3, name: 'THIRD_PARTY_WEB_SEARCH_MODEL_O4_MINI' }, + ], +); +var WorkingDirectoryStatus; +(function (WorkingDirectoryStatus2) { + WorkingDirectoryStatus2[(WorkingDirectoryStatus2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + WorkingDirectoryStatus2[(WorkingDirectoryStatus2['READY'] = 1)] = 'READY'; + WorkingDirectoryStatus2[(WorkingDirectoryStatus2['LOADING'] = 2)] = 'LOADING'; + WorkingDirectoryStatus2[(WorkingDirectoryStatus2['ERROR'] = 3)] = 'ERROR'; +})(WorkingDirectoryStatus || (WorkingDirectoryStatus = {})); +proto3.util.setEnumType( + WorkingDirectoryStatus, + 'exa.codeium_common_pb.WorkingDirectoryStatus', + [ + { no: 0, name: 'WORKING_DIRECTORY_STATUS_UNSPECIFIED' }, + { no: 1, name: 'WORKING_DIRECTORY_STATUS_READY' }, + { no: 2, name: 'WORKING_DIRECTORY_STATUS_LOADING' }, + { no: 3, name: 'WORKING_DIRECTORY_STATUS_ERROR' }, + ], +); +var ArtifactApprovalStatus; +(function (ArtifactApprovalStatus2) { + ArtifactApprovalStatus2[(ArtifactApprovalStatus2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + ArtifactApprovalStatus2[(ArtifactApprovalStatus2['APPROVED'] = 1)] = + 'APPROVED'; + ArtifactApprovalStatus2[(ArtifactApprovalStatus2['REQUESTED_CHANGES'] = 2)] = + 'REQUESTED_CHANGES'; +})(ArtifactApprovalStatus || (ArtifactApprovalStatus = {})); +proto3.util.setEnumType( + ArtifactApprovalStatus, + 'exa.codeium_common_pb.ArtifactApprovalStatus', + [ + { no: 0, name: 'ARTIFACT_APPROVAL_STATUS_UNSPECIFIED' }, + { no: 1, name: 'ARTIFACT_APPROVAL_STATUS_APPROVED' }, + { no: 2, name: 'ARTIFACT_APPROVAL_STATUS_REQUESTED_CHANGES' }, + ], +); +var ArtifactType; +(function (ArtifactType2) { + ArtifactType2[(ArtifactType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ArtifactType2[(ArtifactType2['IMPLEMENTATION_PLAN'] = 1)] = + 'IMPLEMENTATION_PLAN'; + ArtifactType2[(ArtifactType2['WALKTHROUGH'] = 2)] = 'WALKTHROUGH'; + ArtifactType2[(ArtifactType2['TASK'] = 3)] = 'TASK'; + ArtifactType2[(ArtifactType2['OTHER'] = 4)] = 'OTHER'; +})(ArtifactType || (ArtifactType = {})); +proto3.util.setEnumType(ArtifactType, 'exa.codeium_common_pb.ArtifactType', [ + { no: 0, name: 'ARTIFACT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'ARTIFACT_TYPE_IMPLEMENTATION_PLAN' }, + { no: 2, name: 'ARTIFACT_TYPE_WALKTHROUGH' }, + { no: 3, name: 'ARTIFACT_TYPE_TASK' }, + { no: 4, name: 'ARTIFACT_TYPE_OTHER' }, +]); +var BrowserJsAutoRunPolicy; +(function (BrowserJsAutoRunPolicy2) { + BrowserJsAutoRunPolicy2[(BrowserJsAutoRunPolicy2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + BrowserJsAutoRunPolicy2[(BrowserJsAutoRunPolicy2['DISABLED'] = 1)] = + 'DISABLED'; + BrowserJsAutoRunPolicy2[(BrowserJsAutoRunPolicy2['MODEL_DECIDES'] = 2)] = + 'MODEL_DECIDES'; + BrowserJsAutoRunPolicy2[(BrowserJsAutoRunPolicy2['ENABLED'] = 3)] = 'ENABLED'; +})(BrowserJsAutoRunPolicy || (BrowserJsAutoRunPolicy = {})); +proto3.util.setEnumType( + BrowserJsAutoRunPolicy, + 'exa.codeium_common_pb.BrowserJsAutoRunPolicy', + [ + { no: 0, name: 'BROWSER_JS_AUTO_RUN_POLICY_UNSPECIFIED' }, + { no: 1, name: 'BROWSER_JS_AUTO_RUN_POLICY_DISABLED' }, + { no: 2, name: 'BROWSER_JS_AUTO_RUN_POLICY_MODEL_DECIDES' }, + { no: 3, name: 'BROWSER_JS_AUTO_RUN_POLICY_ENABLED' }, + ], +); +var CompletionsRequest = class _CompletionsRequest extends Message { + /** + * @generated from field: exa.codeium_common_pb.CompletionConfiguration configuration = 1; + */ + configuration; + /** + * @generated from field: string prompt = 2; + */ + prompt = ''; + /** + * @generated from field: string serialized_prompt = 26; + */ + serializedPrompt = ''; + /** + * @generated from field: string context_prompt = 21; + */ + contextPrompt = ''; + /** + * Uid is set by the API server. It is used for prompt cache sticky load + * balancing and management of prompt cache lookups / evictions. + * + * @generated from field: string uid = 25; + */ + uid = ''; + /** + * @generated from field: repeated exa.codeium_common_pb.PromptElementRange prompt_element_ranges = 8; + */ + promptElementRanges = []; + /** + * @generated from field: repeated exa.codeium_common_pb.PromptElementKindInfo prompt_element_kind_infos = 9; + */ + promptElementKindInfos = []; + /** + * Prompt generation latency. + * + * @generated from field: uint64 prompt_latency_ms = 11; + */ + promptLatencyMs = protoInt64.zero; + /** + * Latencies for stages of prompt creation (included in prompt_latency_ms). + * + * @generated from field: repeated exa.codeium_common_pb.PromptStageLatency prompt_stage_latencies = 12; + */ + promptStageLatencies = []; + /** + * @generated from field: uint64 num_tokenized_bytes = 20; + */ + numTokenizedBytes = protoInt64.zero; + /** + * @generated from field: string editor_language = 3; + */ + editorLanguage = ''; + /** + * @generated from field: exa.codeium_common_pb.Language language = 4; + */ + language = Language.UNSPECIFIED; + /** + * This used to be an absolute path but is now a URI. + * + * @generated from field: string absolute_path_uri_for_telemetry = 5; + */ + absolutePathUriForTelemetry = ''; + /** + * @generated from field: string relative_path_for_telemetry = 6; + */ + relativePathForTelemetry = ''; + /** + * This used to be an absolute path but is now a URI. + * + * @generated from field: string workspace_uri_for_telemetry = 13; + */ + workspaceUriForTelemetry = ''; + /** + * @generated from field: string experiment_features_json = 7; + */ + experimentFeaturesJson = ''; + /** + * @generated from field: string experiment_variant_json = 19; + */ + experimentVariantJson = ''; + /** + * @generated from field: exa.codeium_common_pb.Model model = 10; + */ + model = Model.UNSPECIFIED; + /** + * @generated from field: bool has_line_suffix = 14; + */ + hasLineSuffix = false; + /** + * @generated from field: bool should_inline_fim = 15; + */ + shouldInlineFim = false; + /** + * @generated from field: exa.codeium_common_pb.Repository repository = 16; + */ + repository; + /** + * Model tag, which will determine which LoRA parameters we use for inference. + * All valid model tags must be nonempty strings (otherwise they will be + * ignored and no LoRA parameters will be used). + * + * @generated from field: string model_tag = 17; + */ + modelTag = ''; + /** + * Free-form string tags for tagging experiments. There may be situations in + * which an experiment is "on", but the prerequisite for it has not been met, + * in which case this field may be of use. + * + * @generated from field: repeated string experiment_tags = 18; + */ + experimentTags = []; + /** + * Evaluation suffix. If specified, the CompletionsResponse will return + * a set of logits corresponding to this eval suffix. Used for lm-eval. + * + * @generated from field: string eval_suffix = 22; + */ + evalSuffix = ''; + /** + * Prompt annotated ranges used for inference. + * + * @generated from field: repeated exa.codeium_common_pb.PromptAnnotationRange prompt_annotation_ranges = 23; + */ + promptAnnotationRanges = []; + /** + * Whether the client supports PackedStreamingCompletionMaps. This should be + * true for updated language servers. + * + * @generated from field: bool supports_packed_streaming_completion_maps = 24; + */ + supportsPackedStreamingCompletionMaps = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionsRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'configuration', + kind: 'message', + T: CompletionConfiguration, + }, + { + no: 2, + name: 'prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 26, + name: 'serialized_prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 21, + name: 'context_prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 25, + name: 'uid', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'prompt_element_ranges', + kind: 'message', + T: PromptElementRange, + repeated: true, + }, + { + no: 9, + name: 'prompt_element_kind_infos', + kind: 'message', + T: PromptElementKindInfo, + repeated: true, + }, + { + no: 11, + name: 'prompt_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 12, + name: 'prompt_stage_latencies', + kind: 'message', + T: PromptStageLatency, + repeated: true, + }, + { + no: 20, + name: 'num_tokenized_bytes', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'editor_language', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { + no: 5, + name: 'absolute_path_uri_for_telemetry', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'relative_path_for_telemetry', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 13, + name: 'workspace_uri_for_telemetry', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'experiment_features_json', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 19, + name: 'experiment_variant_json', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 10, name: 'model', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 14, + name: 'has_line_suffix', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 15, + name: 'should_inline_fim', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 16, name: 'repository', kind: 'message', T: Repository }, + { + no: 17, + name: 'model_tag', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 18, name: 'experiment_tags', kind: 'scalar', T: 9, repeated: true }, + { + no: 22, + name: 'eval_suffix', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 23, + name: 'prompt_annotation_ranges', + kind: 'message', + T: PromptAnnotationRange, + repeated: true, + }, + { + no: 24, + name: 'supports_packed_streaming_completion_maps', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionsRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionsRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionsRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionsRequest, a, b); + } +}; +var CompletionConfiguration = class _CompletionConfiguration extends Message { + /** + * @generated from field: uint64 num_completions = 1; + */ + numCompletions = protoInt64.zero; + /** + * @generated from field: uint64 max_tokens = 2; + */ + maxTokens = protoInt64.zero; + /** + * @generated from field: uint64 max_newlines = 3; + */ + maxNewlines = protoInt64.zero; + /** + * @generated from field: double min_log_probability = 4; + */ + minLogProbability = 0; + /** + * @generated from field: double temperature = 5; + */ + temperature = 0; + /** + * @generated from field: double first_temperature = 6; + */ + firstTemperature = 0; + /** + * @generated from field: uint64 top_k = 7; + */ + topK = protoInt64.zero; + /** + * @generated from field: double top_p = 8; + */ + topP = 0; + /** + * @generated from field: repeated string stop_patterns = 9; + */ + stopPatterns = []; + /** + * @generated from field: uint64 seed = 10; + */ + seed = protoInt64.zero; + /** + * @generated from field: double fim_eot_prob_threshold = 11; + */ + fimEotProbThreshold = 0; + /** + * Whether we use the EOT threshold for FIM generations. + * + * @generated from field: bool use_fim_eot_threshold = 12; + */ + useFimEotThreshold = false; + /** + * If true, do not include stop token log probs in the scores. + * + * @generated from field: bool do_not_score_stop_tokens = 13; + */ + doNotScoreStopTokens = false; + /** + * If true, scores = sum(log probs) / sqrt(completion len) + * + * @generated from field: bool sqrt_len_normalized_log_prob_score = 14; + */ + sqrtLenNormalizedLogProbScore = false; + /** + * For internal chat completions, whether the last chat message is a partial + * message that should be completed, or whether we should start a new message. + * + * @generated from field: bool last_message_is_partial = 15; + */ + lastMessageIsPartial = false; + /** + * Whether to return log probabilities for each token in the completion. + * + * @generated from field: bool return_logprob = 16; + */ + returnLogprob = false; + /** + * @generated from field: bool disable_parallel_tool_calls = 17; + */ + disableParallelToolCalls = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionConfiguration'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'num_completions', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'max_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'max_newlines', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 4, + name: 'min_log_probability', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 5, + name: 'temperature', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 6, + name: 'first_temperature', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 7, + name: 'top_k', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 8, + name: 'top_p', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { no: 9, name: 'stop_patterns', kind: 'scalar', T: 9, repeated: true }, + { + no: 10, + name: 'seed', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 11, + name: 'fim_eot_prob_threshold', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 12, + name: 'use_fim_eot_threshold', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 13, + name: 'do_not_score_stop_tokens', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 14, + name: 'sqrt_len_normalized_log_prob_score', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 15, + name: 'last_message_is_partial', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 16, + name: 'return_logprob', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 17, + name: 'disable_parallel_tool_calls', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionConfiguration().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionConfiguration().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionConfiguration().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionConfiguration, a, b); + } +}; +var PromptElementRange = class _PromptElementRange extends Message { + /** + * @generated from field: exa.codeium_common_pb.PromptElementKind kind = 1; + */ + kind = PromptElementKind.UNSPECIFIED; + /** + * @generated from field: uint64 byte_offset_start = 2; + */ + byteOffsetStart = protoInt64.zero; + /** + * exclusive + * + * @generated from field: uint64 byte_offset_end = 3; + */ + byteOffsetEnd = protoInt64.zero; + /** + * @generated from field: uint64 token_offset_start = 4; + */ + tokenOffsetStart = protoInt64.zero; + /** + * exclusive + * + * @generated from field: uint64 token_offset_end = 5; + */ + tokenOffsetEnd = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PromptElementRange'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'kind', + kind: 'enum', + T: proto3.getEnumType(PromptElementKind), + }, + { + no: 2, + name: 'byte_offset_start', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'byte_offset_end', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 4, + name: 'token_offset_start', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 5, + name: 'token_offset_end', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _PromptElementRange().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptElementRange().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptElementRange().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PromptElementRange, a, b); + } +}; +var ActionPointer = class _ActionPointer extends Message { + /** + * @generated from field: string cortex_plan_id = 1; + */ + cortexPlanId = ''; + /** + * @generated from field: string code_plan_id = 2; + */ + codePlanId = ''; + /** + * -1 is for the latest action in the plan. + * + * @generated from field: int32 action_index = 3; + */ + actionIndex = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ActionPointer'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'cortex_plan_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'code_plan_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'action_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ActionPointer().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActionPointer().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActionPointer().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ActionPointer, a, b); + } +}; +var PromptAnnotationRange = class _PromptAnnotationRange extends Message { + /** + * @generated from field: exa.codeium_common_pb.PromptAnnotationKind kind = 1; + */ + kind = PromptAnnotationKind.UNSPECIFIED; + /** + * @generated from field: uint64 byte_offset_start = 2; + */ + byteOffsetStart = protoInt64.zero; + /** + * exclusive + * + * @generated from field: uint64 byte_offset_end = 3; + */ + byteOffsetEnd = protoInt64.zero; + /** + * Additional string to be used with speculative copy. + * + * @generated from field: string suffix = 4; + */ + suffix = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PromptAnnotationRange'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'kind', + kind: 'enum', + T: proto3.getEnumType(PromptAnnotationKind), + }, + { + no: 2, + name: 'byte_offset_start', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'byte_offset_end', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 4, + name: 'suffix', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _PromptAnnotationRange().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptAnnotationRange().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptAnnotationRange().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PromptAnnotationRange, a, b); + } +}; +var ExperimentWithVariant = class _ExperimentWithVariant extends Message { + /** + * Optionally set if the key_string is in the set of ExperimentKey enums the + * client knows about. + * + * @generated from field: exa.codeium_common_pb.ExperimentKey key = 1 [deprecated = true]; + * @deprecated + */ + key = ExperimentKey.UNSPECIFIED; + /** + * For new clients, this is required. + * + * @generated from field: string key_string = 5; + */ + keyString = ''; + /** + * @generated from field: bool disabled = 6; + */ + disabled = false; + /** + * If there is no variant, payload is not set. + * + * @generated from oneof exa.codeium_common_pb.ExperimentWithVariant.payload + */ + payload = { case: void 0 }; + /** + * The part of the stack where the experiment was resolved. + * + * @generated from field: exa.codeium_common_pb.ExperimentSource source = 7; + */ + source = ExperimentSource.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ExperimentWithVariant'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'key', kind: 'enum', T: proto3.getEnumType(ExperimentKey) }, + { + no: 5, + name: 'key_string', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'disabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 2, name: 'string', kind: 'scalar', T: 9, oneof: 'payload' }, + { no: 3, name: 'json', kind: 'scalar', T: 9, oneof: 'payload' }, + { no: 4, name: 'csv', kind: 'scalar', T: 9, oneof: 'payload' }, + { + no: 7, + name: 'source', + kind: 'enum', + T: proto3.getEnumType(ExperimentSource), + }, + ]); + static fromBinary(bytes, options) { + return new _ExperimentWithVariant().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ExperimentWithVariant().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ExperimentWithVariant().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ExperimentWithVariant, a, b); + } +}; +var ExperimentConfig = class _ExperimentConfig extends Message { + /** + * All experiments. + * + * @generated from field: repeated exa.codeium_common_pb.ExperimentWithVariant experiments = 6; + */ + experiments = []; + /** + * TODO(prem): Add back "[(buf.validate.field).repeated.unique = true]" after + * https://github.com/bufbuild/protovalidate-go/issues/87 is resolved. + * + * @generated from field: repeated exa.codeium_common_pb.ExperimentKey force_enable_experiments = 1; + */ + forceEnableExperiments = []; + /** + * @generated from field: repeated exa.codeium_common_pb.ExperimentKey force_disable_experiments = 2; + */ + forceDisableExperiments = []; + /** + * @generated from field: repeated exa.codeium_common_pb.ExperimentWithVariant force_enable_experiments_with_variants = 3; + */ + forceEnableExperimentsWithVariants = []; + /** + * Experiment keys are parsed by the extension. However, there are cases when + * the language server may expect experiment keys not known to the compiled + * version of the extension. In these cases, we can attempt to parse the + * strings directly. This will be best-effort and unioned with the keys in the + * previous fields. + * + * @generated from field: repeated string force_enable_experiment_strings = 4; + */ + forceEnableExperimentStrings = []; + /** + * @generated from field: repeated string force_disable_experiment_strings = 5; + */ + forceDisableExperimentStrings = []; + /** + * @generated from field: bool dev_mode = 7; + */ + devMode = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ExperimentConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 6, + name: 'experiments', + kind: 'message', + T: ExperimentWithVariant, + repeated: true, + }, + { + no: 1, + name: 'force_enable_experiments', + kind: 'enum', + T: proto3.getEnumType(ExperimentKey), + repeated: true, + }, + { + no: 2, + name: 'force_disable_experiments', + kind: 'enum', + T: proto3.getEnumType(ExperimentKey), + repeated: true, + }, + { + no: 3, + name: 'force_enable_experiments_with_variants', + kind: 'message', + T: ExperimentWithVariant, + repeated: true, + }, + { + no: 4, + name: 'force_enable_experiment_strings', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 5, + name: 'force_disable_experiment_strings', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 7, + name: 'dev_mode', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ExperimentConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ExperimentConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ExperimentConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ExperimentConfig, a, b); + } +}; +var ExperimentLanguageServerVersionPayload = class _ExperimentLanguageServerVersionPayload extends Message { + /** + * @generated from field: string sha = 1; + */ + sha = ''; + /** + * @generated from field: string crc32c_linux_x64 = 2; + */ + crc32cLinuxX64 = ''; + /** + * @generated from field: string crc32c_linux_arm = 3; + */ + crc32cLinuxArm = ''; + /** + * @generated from field: string crc32c_macos_x64 = 4; + */ + crc32cMacosX64 = ''; + /** + * @generated from field: string crc32c_macos_arm = 5; + */ + crc32cMacosArm = ''; + /** + * @generated from field: string crc32c_windows_x64 = 6; + */ + crc32cWindowsX64 = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.codeium_common_pb.ExperimentLanguageServerVersionPayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'sha', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'crc32c_linux_x64', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'crc32c_linux_arm', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'crc32c_macos_x64', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'crc32c_macos_arm', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'crc32c_windows_x64', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ExperimentLanguageServerVersionPayload().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _ExperimentLanguageServerVersionPayload().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _ExperimentLanguageServerVersionPayload().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ExperimentLanguageServerVersionPayload, a, b); + } +}; +var ExperimentModelConfigPayload = class _ExperimentModelConfigPayload extends Message { + /** + * Generation model. + * + * @generated from field: string model_name = 1; + */ + modelName = ''; + /** + * Context check model. + * + * @generated from field: string context_check_model_name = 2; + */ + contextCheckModelName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ExperimentModelConfigPayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'context_check_model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ExperimentModelConfigPayload().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ExperimentModelConfigPayload().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ExperimentModelConfigPayload().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ExperimentModelConfigPayload, a, b); + } +}; +var ExperimentMiddleModeTokenPayload = class _ExperimentMiddleModeTokenPayload extends Message { + /** + * Mode token. + * + * @generated from field: string mode_token = 1; + */ + modeToken = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ExperimentMiddleModeTokenPayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'mode_token', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ExperimentMiddleModeTokenPayload().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ExperimentMiddleModeTokenPayload().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ExperimentMiddleModeTokenPayload().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ExperimentMiddleModeTokenPayload, a, b); + } +}; +var ExperimentMultilineModelThresholdPayload = class _ExperimentMultilineModelThresholdPayload extends Message { + /** + * Multiline model threshold. + * + * @generated from field: float threshold = 1; + */ + threshold = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.codeium_common_pb.ExperimentMultilineModelThresholdPayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'threshold', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + ]); + static fromBinary(bytes, options) { + return new _ExperimentMultilineModelThresholdPayload().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _ExperimentMultilineModelThresholdPayload().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _ExperimentMultilineModelThresholdPayload().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ExperimentMultilineModelThresholdPayload, a, b); + } +}; +var ExperimentSentryPayload = class _ExperimentSentryPayload extends Message { + /** + * Sample rate for errors. Used if there is no procedure-specific rate/ignore + * string-specific rate. + * + * @generated from field: double sample_rate = 2; + */ + sampleRate = 0; + /** + * Sample rate for errors with a matching procedure. Used if there is no + * ignore string-specific rate. + * + * @generated from field: map procedure_to_sample_rate = 3; + */ + procedureToSampleRate = {}; + /** + * Sample rate for errors with a matching ignore string. + * + * @generated from field: map error_match_to_sample_rate = 5; + */ + errorMatchToSampleRate = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ExperimentSentryPayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 2, + name: 'sample_rate', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 3, + name: 'procedure_to_sample_rate', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + }, + { + no: 5, + name: 'error_match_to_sample_rate', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _ExperimentSentryPayload().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ExperimentSentryPayload().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ExperimentSentryPayload().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ExperimentSentryPayload, a, b); + } +}; +var TeamOrganizationalControls = class _TeamOrganizationalControls extends Message { + /** + * @generated from field: string team_id = 1; + */ + teamId = ''; + /** + * List of model labels like "Claude 3.5 Sonnet" that can be used by + * + * @generated from field: repeated string cascade_model_labels = 2; + */ + cascadeModelLabels = []; + /** + * Cascade. + * + * List of model labels like "Claude 3.5 Sonnet" that can be used by + * + * @generated from field: repeated string command_model_labels = 3; + */ + commandModelLabels = []; + /** + * Command. + * + * @generated from field: google.protobuf.Timestamp created_at = 4; + */ + createdAt; + /** + * @generated from field: google.protobuf.Timestamp updated_at = 5; + */ + updatedAt; + /** + * List of model labels like "Claude 3.5 Sonnet" that can be used by + * + * @generated from field: repeated string extension_model_labels = 6; + */ + extensionModelLabels = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TeamOrganizationalControls'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'team_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'cascade_model_labels', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 3, + name: 'command_model_labels', + kind: 'scalar', + T: 9, + repeated: true, + }, + { no: 4, name: 'created_at', kind: 'message', T: Timestamp }, + { no: 5, name: 'updated_at', kind: 'message', T: Timestamp }, + { + no: 6, + name: 'extension_model_labels', + kind: 'scalar', + T: 9, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _TeamOrganizationalControls().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TeamOrganizationalControls().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TeamOrganizationalControls().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_TeamOrganizationalControls, a, b); + } +}; +var ExperimentProfilingTelemetrySampleRatePayload = class _ExperimentProfilingTelemetrySampleRatePayload extends Message { + /** + * Sample rate for profiling telemetry by memory usage. + * + * @generated from field: map memory_usage_to_sample_rate = 1; + */ + memoryUsageToSampleRate = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.codeium_common_pb.ExperimentProfilingTelemetrySampleRatePayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'memory_usage_to_sample_rate', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _ExperimentProfilingTelemetrySampleRatePayload().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _ExperimentProfilingTelemetrySampleRatePayload().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _ExperimentProfilingTelemetrySampleRatePayload().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals( + _ExperimentProfilingTelemetrySampleRatePayload, + a, + b, + ); + } +}; +var ModelOrAlias = class _ModelOrAlias extends Message { + /** + * @generated from oneof exa.codeium_common_pb.ModelOrAlias.choice + */ + choice = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ModelOrAlias'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'model', + kind: 'enum', + T: proto3.getEnumType(Model), + oneof: 'choice', + }, + { + no: 2, + name: 'alias', + kind: 'enum', + T: proto3.getEnumType(ModelAlias), + oneof: 'choice', + }, + ]); + static fromBinary(bytes, options) { + return new _ModelOrAlias().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelOrAlias().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ModelOrAlias().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ModelOrAlias, a, b); + } +}; +var PromptElementKindInfo = class _PromptElementKindInfo extends Message { + /** + * @generated from field: exa.codeium_common_pb.PromptElementKind kind = 1; + */ + kind = PromptElementKind.UNSPECIFIED; + /** + * The key for the associated experiment if it exists. + * + * @generated from field: exa.codeium_common_pb.ExperimentKey experiment_key = 2; + */ + experimentKey = ExperimentKey.UNSPECIFIED; + /** + * Whether the experiment is enabled (should be true if no associated + * experiment). + * + * @generated from field: bool enabled = 3; + */ + enabled = false; + /** + * The number of elements of this kind considered when constructing the + * prompt. If the experiment is disabled, this will be the number considered + * as if the experiment were enabled. + * + * @generated from field: uint64 num_considered = 4; + */ + numConsidered = protoInt64.zero; + /** + * The number of elements of this kind included when constructing the prompt. + * If the experiment is disabled, this will be the number included as if the + * experiment were enabled. + * + * @generated from field: uint64 num_included = 5; + */ + numIncluded = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PromptElementKindInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'kind', + kind: 'enum', + T: proto3.getEnumType(PromptElementKind), + }, + { + no: 2, + name: 'experiment_key', + kind: 'enum', + T: proto3.getEnumType(ExperimentKey), + }, + { + no: 3, + name: 'enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'num_considered', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 5, + name: 'num_included', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _PromptElementKindInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptElementKindInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptElementKindInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PromptElementKindInfo, a, b); + } +}; +var PromptElementInclusionMetadata = class _PromptElementInclusionMetadata extends Message { + /** + * Whether prompt item was included in the prompt. + * + * @generated from field: bool included = 1; + */ + included = false; + /** + * Only populated if not `included`. + * + * @generated from field: exa.codeium_common_pb.PromptElementExclusionReason exclusion_reason = 2; + */ + exclusionReason = PromptElementExclusionReason.EXCLUSION_UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PromptElementInclusionMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'included', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'exclusion_reason', + kind: 'enum', + T: proto3.getEnumType(PromptElementExclusionReason), + }, + ]); + static fromBinary(bytes, options) { + return new _PromptElementInclusionMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptElementInclusionMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptElementInclusionMetadata().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_PromptElementInclusionMetadata, a, b); + } +}; +var PromptStageLatency = class _PromptStageLatency extends Message { + /** + * @generated from field: string name = 1; + */ + name = ''; + /** + * @generated from field: uint64 latency_ms = 2; + */ + latencyMs = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PromptStageLatency'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _PromptStageLatency().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptStageLatency().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptStageLatency().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PromptStageLatency, a, b); + } +}; +var CompletionResponse = class _CompletionResponse extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.Completion completions = 1; + */ + completions = []; + /** + * @generated from field: uint64 max_tokens = 2; + */ + maxTokens = protoInt64.zero; + /** + * @generated from field: double temperature = 3; + */ + temperature = 0; + /** + * @generated from field: uint64 top_k = 4; + */ + topK = protoInt64.zero; + /** + * @generated from field: double top_p = 5; + */ + topP = 0; + /** + * @generated from field: repeated string stop_patterns = 6; + */ + stopPatterns = []; + /** + * @generated from field: uint64 prompt_length = 7; + */ + promptLength = protoInt64.zero; + /** + * Populated by the API server. + * + * @generated from field: string prompt_id = 8; + */ + promptId = ''; + /** + * @generated from field: string model_tag = 10; + */ + modelTag = ''; + /** + * @generated from field: optional exa.codeium_common_pb.CompletionProfile completion_profile = 11; + */ + completionProfile; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'completions', + kind: 'message', + T: Completion, + repeated: true, + }, + { + no: 2, + name: 'max_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'temperature', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 4, + name: 'top_k', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 5, + name: 'top_p', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { no: 6, name: 'stop_patterns', kind: 'scalar', T: 9, repeated: true }, + { + no: 7, + name: 'prompt_length', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 8, + name: 'prompt_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'model_tag', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 11, + name: 'completion_profile', + kind: 'message', + T: CompletionProfile, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionResponse, a, b); + } +}; +var Completion = class _Completion extends Message { + /** + * @generated from field: string completion_id = 1; + */ + completionId = ''; + /** + * @generated from field: string text = 2; + */ + text = ''; + /** + * @generated from field: string stop = 4; + */ + stop = ''; + /** + * Populated / overwritten on the language server, derived from probabilities. + * + * @generated from field: double score = 5; + */ + score = 0; + /** + * @generated from field: repeated uint64 tokens = 6; + */ + tokens = []; + /** + * @generated from field: repeated string decoded_tokens = 7; + */ + decodedTokens = []; + /** + * @generated from field: repeated double probabilities = 8; + */ + probabilities = []; + /** + * @generated from field: repeated double adjusted_probabilities = 9; + */ + adjustedProbabilities = []; + /** + * @generated from field: repeated double logprobs = 16; + */ + logprobs = []; + /** + * @generated from field: uint64 generated_length = 10; + */ + generatedLength = protoInt64.zero; + /** + * Reason that the completion was stopped. Can be populated by the inference + * server or the language server. + * + * @generated from field: exa.codeium_common_pb.StopReason stop_reason = 12; + */ + stopReason = StopReason.UNSPECIFIED; + /** + * Reasons that the completion was filtered (if filtered). Will be populated + * by the language server. + * + * @generated from field: repeated exa.codeium_common_pb.FilterReason filter_reasons = 13; + */ + filterReasons = []; + /** + * Original text prior to cutoff / cleaning. Will be populated by the language + * server. + * + * @generated from field: string original_text = 14; + */ + originalText = ''; + /** + * Tool calls generated by the model. Populated by the language server / api + * server. + * + * @generated from field: repeated exa.codeium_common_pb.ChatToolCall tool_calls = 15; + */ + toolCalls = []; + /** + * Trace ID from the backend for debugging and observability. + * + * @generated from field: string trace_id = 17; + */ + traceId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Completion'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'completion_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'stop', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'score', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { no: 6, name: 'tokens', kind: 'scalar', T: 4, repeated: true }, + { no: 7, name: 'decoded_tokens', kind: 'scalar', T: 9, repeated: true }, + { no: 8, name: 'probabilities', kind: 'scalar', T: 1, repeated: true }, + { + no: 9, + name: 'adjusted_probabilities', + kind: 'scalar', + T: 1, + repeated: true, + }, + { no: 16, name: 'logprobs', kind: 'scalar', T: 1, repeated: true }, + { + no: 10, + name: 'generated_length', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 12, + name: 'stop_reason', + kind: 'enum', + T: proto3.getEnumType(StopReason), + }, + { + no: 13, + name: 'filter_reasons', + kind: 'enum', + T: proto3.getEnumType(FilterReason), + repeated: true, + }, + { + no: 14, + name: 'original_text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 15, + name: 'tool_calls', + kind: 'message', + T: ChatToolCall, + repeated: true, + }, + { + no: 17, + name: 'trace_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _Completion().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Completion().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Completion().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Completion, a, b); + } +}; +var StreamingCompletionInfo = class _StreamingCompletionInfo extends Message { + /** + * List of the completion uuid strings corresponding to each completion for a + * sequence. The length of this list shall equal num_completions. + * The i-th element of completion_ids will be the completion uuid for + * completion index i (that is, the i-th completion of this sequence). + * + * @generated from field: repeated string completion_ids = 1; + */ + completionIds = []; + /** + * @generated from field: uint64 max_tokens = 2; + */ + maxTokens = protoInt64.zero; + /** + * @generated from field: double temperature = 3; + */ + temperature = 0; + /** + * @generated from field: uint64 top_k = 4; + */ + topK = protoInt64.zero; + /** + * @generated from field: double top_p = 5; + */ + topP = 0; + /** + * @generated from field: repeated string stop_patterns = 6; + */ + stopPatterns = []; + /** + * @generated from field: uint64 prompt_length = 7; + */ + promptLength = protoInt64.zero; + /** + * Populated by the API server. + * + * @generated from field: string prompt_id = 9; + */ + promptId = ''; + /** + * @generated from field: string model_tag = 8; + */ + modelTag = ''; + /** + * This is only returned for dev requests if the CompletionsRequest object was + * modified on the server. + * + * @generated from field: exa.codeium_common_pb.CompletionsRequest completions_request = 10; + */ + completionsRequest; + /** + * Info on the logits and tokens of the eval_suffix from the completions + * request. This is only populated if the eval_suffix was not empty. + * Note that we put this message into StreamingCompletionInfo so that it can + * pass through the api server. + * + * @generated from field: exa.codeium_common_pb.StreamingEvalSuffixInfo eval_suffix_info = 11; + */ + evalSuffixInfo; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.StreamingCompletionInfo'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'completion_ids', kind: 'scalar', T: 9, repeated: true }, + { + no: 2, + name: 'max_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'temperature', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 4, + name: 'top_k', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 5, + name: 'top_p', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { no: 6, name: 'stop_patterns', kind: 'scalar', T: 9, repeated: true }, + { + no: 7, + name: 'prompt_length', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 9, + name: 'prompt_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'model_tag', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'completions_request', + kind: 'message', + T: CompletionsRequest, + }, + { + no: 11, + name: 'eval_suffix_info', + kind: 'message', + T: StreamingEvalSuffixInfo, + }, + ]); + static fromBinary(bytes, options) { + return new _StreamingCompletionInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StreamingCompletionInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StreamingCompletionInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_StreamingCompletionInfo, a, b); + } +}; +var SingleModelCompletionProfile = class _SingleModelCompletionProfile extends Message { + /** + * Profile information for the completion + * + * @generated from field: double total_prefill_pass_time = 1; + */ + totalPrefillPassTime = 0; + /** + * @generated from field: double avg_prefill_pass_time = 2; + */ + avgPrefillPassTime = 0; + /** + * @generated from field: uint64 num_prefill_passes = 3; + */ + numPrefillPasses = protoInt64.zero; + /** + * @generated from field: double total_spec_copy_pass_time = 7; + */ + totalSpecCopyPassTime = 0; + /** + * @generated from field: double avg_spec_copy_pass_time = 8; + */ + avgSpecCopyPassTime = 0; + /** + * @generated from field: uint64 num_spec_copy_passes = 9; + */ + numSpecCopyPasses = protoInt64.zero; + /** + * @generated from field: double total_generation_pass_time = 4; + */ + totalGenerationPassTime = 0; + /** + * @generated from field: double avg_generation_pass_time = 5; + */ + avgGenerationPassTime = 0; + /** + * @generated from field: uint64 num_generation_passes = 6; + */ + numGenerationPasses = protoInt64.zero; + /** + * @generated from field: double total_model_time = 10; + */ + totalModelTime = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.SingleModelCompletionProfile'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'total_prefill_pass_time', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 2, + name: 'avg_prefill_pass_time', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 3, + name: 'num_prefill_passes', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 7, + name: 'total_spec_copy_pass_time', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 8, + name: 'avg_spec_copy_pass_time', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 9, + name: 'num_spec_copy_passes', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 4, + name: 'total_generation_pass_time', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 5, + name: 'avg_generation_pass_time', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 6, + name: 'num_generation_passes', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 10, + name: 'total_model_time', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + ]); + static fromBinary(bytes, options) { + return new _SingleModelCompletionProfile().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SingleModelCompletionProfile().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SingleModelCompletionProfile().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_SingleModelCompletionProfile, a, b); + } +}; +var CompletionProfile = class _CompletionProfile extends Message { + /** + * @generated from field: exa.codeium_common_pb.SingleModelCompletionProfile model_profile = 1; + */ + modelProfile; + /** + * @generated from field: optional exa.codeium_common_pb.SingleModelCompletionProfile draft_model_profile = 2; + */ + draftModelProfile; + /** + * Time from server receiving completion request to first prefill pass (i.e. + * time waiting in the prefill queue) + * + * @generated from field: double time_to_first_prefill_pass = 3; + */ + timeToFirstPrefillPass = 0; + /** + * Time from server receiving completion request to prefill completion + * + * @generated from field: double time_to_first_token = 4; + */ + timeToFirstToken = 0; + /** + * Total time from server receiving completion request to end of completion + * + * @generated from field: double total_completion_time = 5; + */ + totalCompletionTime = 0; + /** + * Model usage stats for API server + * + * @generated from field: optional exa.codeium_common_pb.ModelUsageStats model_usage = 6; + */ + modelUsage; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionProfile'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'model_profile', + kind: 'message', + T: SingleModelCompletionProfile, + }, + { + no: 2, + name: 'draft_model_profile', + kind: 'message', + T: SingleModelCompletionProfile, + opt: true, + }, + { + no: 3, + name: 'time_to_first_prefill_pass', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 4, + name: 'time_to_first_token', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 5, + name: 'total_completion_time', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 6, + name: 'model_usage', + kind: 'message', + T: ModelUsageStats, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionProfile().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionProfile().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionProfile().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionProfile, a, b); + } +}; +var StreamingCompletion = class _StreamingCompletion extends Message { + /** + * Note that we report back the decoded_token as bytes, because a single + * token's corresponding bytes may not be valid UTF-8. It is the caller's + * responsibility to concatenate these bytes and decode them in a valid + * manner. + * + * @generated from field: bytes decoded_token = 1; + */ + decodedToken = new Uint8Array(0); + /** + * @generated from field: uint64 token = 2; + */ + token = protoInt64.zero; + /** + * @generated from field: double probability = 3; + */ + probability = 0; + /** + * @generated from field: double adjusted_probability = 4; + */ + adjustedProbability = 0; + /** + * @generated from field: double logprob = 9; + */ + logprob = 0; + /** + * If true, we are signaling to the caller that the completion is finished + * (i.e. encountered stop pattern or reached max tokens), and guarantee that + * this will never appear in the StreamingCompletionMap for subsequently + * written StreamingCompletionResponse messages for this sequence. + * + * @generated from field: bool completion_finished = 5; + */ + completionFinished = false; + /** + * Stop pattern for the completion if applicable. + * + * @generated from field: string stop = 6; + */ + stop = ''; + /** + * Optional server-side stop reason. Should be set when completion_finished is + * set to true. + * + * @generated from field: exa.codeium_common_pb.StopReason stop_reason = 7; + */ + stopReason = StopReason.UNSPECIFIED; + /** + * Map from offset within the decoded token to attribution status. This will + * have entries for each newline byte or beginning of EOM token in the chunk. + * + * @generated from field: map attribution_statuses = 8; + */ + attributionStatuses = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.StreamingCompletion'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'decoded_token', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + { + no: 2, + name: 'token', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'probability', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 4, + name: 'adjusted_probability', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 9, + name: 'logprob', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { + no: 5, + name: 'completion_finished', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'stop', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'stop_reason', + kind: 'enum', + T: proto3.getEnumType(StopReason), + }, + { + no: 8, + name: 'attribution_statuses', + kind: 'map', + K: 13, + V: { kind: 'enum', T: proto3.getEnumType(AttributionStatus) }, + }, + ]); + static fromBinary(bytes, options) { + return new _StreamingCompletion().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StreamingCompletion().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StreamingCompletion().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_StreamingCompletion, a, b); + } +}; +var StreamingCompletionMap = class _StreamingCompletionMap extends Message { + /** + * Map the completion index to the StreamingCompletion containing the next + * token for that completion. That is, completions[i] contains the next token + * for the i-th completion of this sequence. Note that we need this because + * different completions may end at different points, and after a completion + * reaches a stop pattern we should stop writing StreamingCompletions for it + * to the stream. + * + * @generated from field: map completions = 1; + */ + completions = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.StreamingCompletionMap'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'completions', + kind: 'map', + K: 5, + V: { kind: 'message', T: StreamingCompletion }, + }, + ]); + static fromBinary(bytes, options) { + return new _StreamingCompletionMap().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StreamingCompletionMap().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StreamingCompletionMap().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_StreamingCompletionMap, a, b); + } +}; +var PackedStreamingCompletionMaps = class _PackedStreamingCompletionMaps extends Message { + /** + * Packs StreamingCompletionMaps for multiple tokens into a single message. + * + * @generated from field: repeated exa.codeium_common_pb.StreamingCompletionMap completion_maps = 1; + */ + completionMaps = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PackedStreamingCompletionMaps'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'completion_maps', + kind: 'message', + T: StreamingCompletionMap, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _PackedStreamingCompletionMaps().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PackedStreamingCompletionMaps().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PackedStreamingCompletionMaps().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_PackedStreamingCompletionMaps, a, b); + } +}; +var StreamingEvalSuffixInfo = class _StreamingEvalSuffixInfo extends Message { + /** + * The per-token log likelihood of the "eval suffix", which is a suffix + * that is concatenated onto the "original" prompt (i.e. the prompt field + * in the CompletionsRequest). Note that these log likelihoods are computed + * conditional on the original prompt. + * + * @generated from field: repeated float per_token_log_likelihoods = 1; + */ + perTokenLogLikelihoods = []; + /** + * Whether the eval suffix would have been generated by greedy sampling. + * + * @generated from field: bool is_greedy = 2; + */ + isGreedy = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.StreamingEvalSuffixInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'per_token_log_likelihoods', + kind: 'scalar', + T: 2, + repeated: true, + }, + { + no: 2, + name: 'is_greedy', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _StreamingEvalSuffixInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StreamingEvalSuffixInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StreamingEvalSuffixInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_StreamingEvalSuffixInfo, a, b); + } +}; +var StreamingCompletionResponse = class _StreamingCompletionResponse extends Message { + /** + * @generated from oneof exa.codeium_common_pb.StreamingCompletionResponse.payload + */ + payload = { case: void 0 }; + /** + * Profile information for the completion + * + * @generated from field: optional exa.codeium_common_pb.CompletionProfile completion_profile = 5; + */ + completionProfile; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.StreamingCompletionResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'completion_info', + kind: 'message', + T: StreamingCompletionInfo, + oneof: 'payload', + }, + { + no: 2, + name: 'completion_map', + kind: 'message', + T: StreamingCompletionMap, + oneof: 'payload', + }, + { + no: 4, + name: 'packed_completion_maps', + kind: 'message', + T: PackedStreamingCompletionMaps, + oneof: 'payload', + }, + { + no: 5, + name: 'completion_profile', + kind: 'message', + T: CompletionProfile, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _StreamingCompletionResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StreamingCompletionResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StreamingCompletionResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_StreamingCompletionResponse, a, b); + } +}; +var CompletionLatencyInfo = class _CompletionLatencyInfo extends Message { + /** + * Full completion latencies. + * API server-measured API server RPC latency. + * + * @generated from field: uint64 api_server_latency_ms = 1; + */ + apiServerLatencyMs = protoInt64.zero; + /** + * Language server-measured API server RPC latency. + * + * @generated from field: uint64 language_server_latency_ms = 2; + */ + languageServerLatencyMs = protoInt64.zero; + /** + * Network latency for API server RPC. + * + * @generated from field: uint64 network_latency_ms = 3; + */ + networkLatencyMs = protoInt64.zero; + /** + * First byte latencies. + * + * @generated from field: uint64 api_server_first_byte_latency_ms = 4; + */ + apiServerFirstByteLatencyMs = protoInt64.zero; + /** + * @generated from field: uint64 language_server_first_byte_latency_ms = 5; + */ + languageServerFirstByteLatencyMs = protoInt64.zero; + /** + * @generated from field: uint64 network_first_byte_latency_ms = 6; + */ + networkFirstByteLatencyMs = protoInt64.zero; + /** + * First line latencies. + * + * @generated from field: uint64 api_server_first_line_latency_ms = 7; + */ + apiServerFirstLineLatencyMs = protoInt64.zero; + /** + * @generated from field: uint64 language_server_first_line_latency_ms = 8; + */ + languageServerFirstLineLatencyMs = protoInt64.zero; + /** + * @generated from field: uint64 network_first_line_latency_ms = 9; + */ + networkFirstLineLatencyMs = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionLatencyInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'api_server_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'language_server_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'network_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 4, + name: 'api_server_first_byte_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 5, + name: 'language_server_first_byte_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 6, + name: 'network_first_byte_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 7, + name: 'api_server_first_line_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 8, + name: 'language_server_first_line_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 9, + name: 'network_first_line_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionLatencyInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionLatencyInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionLatencyInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionLatencyInfo, a, b); + } +}; +var CompletionWithLatencyInfo = class _CompletionWithLatencyInfo extends Message { + /** + * @generated from field: exa.codeium_common_pb.Completion completion = 1; + */ + completion; + /** + * @generated from field: exa.codeium_common_pb.CompletionLatencyInfo latency_info = 2; + */ + latencyInfo; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionWithLatencyInfo'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'completion', kind: 'message', T: Completion }, + { no: 2, name: 'latency_info', kind: 'message', T: CompletionLatencyInfo }, + ]); + static fromBinary(bytes, options) { + return new _CompletionWithLatencyInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionWithLatencyInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionWithLatencyInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionWithLatencyInfo, a, b); + } +}; +var EmbeddingsRequest = class _EmbeddingsRequest extends Message { + /** + * @generated from field: repeated string prompts = 1; + */ + prompts = []; + /** + * @generated from field: exa.codeium_common_pb.EmbeddingPriority priority = 2; + */ + priority = EmbeddingPriority.UNSPECIFIED; + /** + * @generated from field: exa.codeium_common_pb.EmbeddingPrefix prefix = 3; + */ + prefix = EmbeddingPrefix.UNSPECIFIED; + /** + * @generated from field: exa.codeium_common_pb.Model model = 4; + */ + model = Model.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.EmbeddingsRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'prompts', kind: 'scalar', T: 9, repeated: true }, + { + no: 2, + name: 'priority', + kind: 'enum', + T: proto3.getEnumType(EmbeddingPriority), + }, + { + no: 3, + name: 'prefix', + kind: 'enum', + T: proto3.getEnumType(EmbeddingPrefix), + }, + { no: 4, name: 'model', kind: 'enum', T: proto3.getEnumType(Model) }, + ]); + static fromBinary(bytes, options) { + return new _EmbeddingsRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _EmbeddingsRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _EmbeddingsRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_EmbeddingsRequest, a, b); + } +}; +var Embedding = class _Embedding extends Message { + /** + * Represents a single embedding. values shall have length = embed_dim of the + * embedding model. + * + * @generated from field: repeated float values = 1; + */ + values = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Embedding'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'values', kind: 'scalar', T: 2, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _Embedding().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Embedding().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Embedding().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Embedding, a, b); + } +}; +var EmbeddingResponse = class _EmbeddingResponse extends Message { + /** + * Embeddings returned in the same order as the prompts that were submitted in + * the EmbeddingsRequest. + * + * @generated from field: repeated exa.codeium_common_pb.Embedding embeddings = 1; + */ + embeddings = []; + /** + * @generated from field: bool prompts_exceeded_context_length = 2; + */ + promptsExceededContextLength = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.EmbeddingResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'embeddings', + kind: 'message', + T: Embedding, + repeated: true, + }, + { + no: 2, + name: 'prompts_exceeded_context_length', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _EmbeddingResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _EmbeddingResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _EmbeddingResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_EmbeddingResponse, a, b); + } +}; +var RewardsRequest = class _RewardsRequest extends Message { + /** + * repeated string prompts = 1; // Items to score + * + * Prefix to items + * + * @generated from field: string prefix = 2; + */ + prefix = ''; + /** + * items should already be wrapped with any special tokens in string form. + * The model relies on the hidden state of the last token, so that should + * usually be a special token. + * + * @generated from field: repeated string items = 3; + */ + items = []; + /** + * For llama models, wrap entire prompt in "[INST][/INST]\nRESPONSE:\n" + * + * @generated from field: bool has_instruct_tokens = 4; + */ + hasInstructTokens = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.RewardsRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 2, + name: 'prefix', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'items', kind: 'scalar', T: 9, repeated: true }, + { + no: 4, + name: 'has_instruct_tokens', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _RewardsRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RewardsRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RewardsRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RewardsRequest, a, b); + } +}; +var RewardsResponse = class _RewardsResponse extends Message { + /** + * Scores returned in the same order as the prompts that were submitted in. + * + * @generated from field: repeated float values = 1; + */ + values = []; + /** + * @generated from field: bool prompts_exceeded_context_length = 2; + */ + promptsExceededContextLength = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.RewardsResponse'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'values', kind: 'scalar', T: 2, repeated: true }, + { + no: 2, + name: 'prompts_exceeded_context_length', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _RewardsResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RewardsResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RewardsResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RewardsResponse, a, b); + } +}; +var Metadata = class _Metadata extends Message { + /** + * Name of IDE (antigravity, jetski, jetski-insiders, etc.) + * + * @generated from field: string ide_name = 1; + */ + ideName = ''; + /** + * Jetski / Antigravity version + * + * @generated from field: string ide_version = 7; + */ + ideVersion = ''; + /** + * Should be same as IDE name. + * + * @generated from field: string extension_name = 12; + */ + extensionName = ''; + /** + * Language server version. + * + * @generated from field: string extension_version = 2; + */ + extensionVersion = ''; + /** + * Path for extension (to determine VSCode Fork). + * + * @generated from field: string extension_path = 17; + */ + extensionPath = ''; + /** + * Locale of the user. + * + * @generated from field: string locale = 4; + */ + locale = ''; + /** + * JSON encoding of os version. Populated by LS client interceptor. + * + * @generated from field: string os = 5; + */ + os = ''; + /** + * JSON encoding of hardware version. + * + * @generated from field: string hardware = 8; + */ + hardware = ''; + /** + * UID for a session. + * + * @generated from field: string session_id = 10; + */ + sessionId = ''; + /** + * Device identifier used to prevent duplicate trial accounts. + * + * @generated from field: string device_fingerprint = 24; + */ + deviceFingerprint = ''; + /** + * Paid GCA tier of the user (e.g. g1-pro-tier) + * + * @generated from field: string user_tier_id = 29; + */ + userTierId = ''; + /** + * Timestamp message reaches language server. For GetChatMessage requests, + * this has been repurposed to be updated right before the request is sent to + * the API server for verification purposes. + * + * @generated from field: google.protobuf.Timestamp ls_timestamp = 16; + */ + lsTimestamp; + /** + * Optional field to link different kinds of completion requests together. + * + * @generated from field: string trigger_id = 25; + */ + triggerId = ''; + /** + * Used to verify the authenticity of requests. Populated by LS client + * interceptor. + * + * @generated from field: string id = 27; + */ + id = ''; + /** + * Not a UUID check due to external auth source support. + * TODO(nick): remove when removing old auth. + * + * @generated from field: string api_key = 3; + */ + apiKey = ''; + /** + * Whether telemetry is disabled at an IDE level. Note that this is separate + * from disabling code snippet telemetry. + * TODO(nick): see if this is removable. + * + * @generated from field: bool disable_telemetry = 6; + */ + disableTelemetry = false; + /** + * User tags for telemetry. + * + * @generated from field: repeated string user_tags = 18; + */ + userTags = []; + /** + * Region code (country) of the user. + * + * @generated from field: string region_code = 30; + */ + regionCode = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Metadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'ide_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'ide_version', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'extension_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'extension_version', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 17, + name: 'extension_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'locale', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'os', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'hardware', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'session_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 24, + name: 'device_fingerprint', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 29, + name: 'user_tier_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 16, name: 'ls_timestamp', kind: 'message', T: Timestamp }, + { + no: 25, + name: 'trigger_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 27, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'api_key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'disable_telemetry', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 18, name: 'user_tags', kind: 'scalar', T: 9, repeated: true }, + { + no: 30, + name: 'region_code', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _Metadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Metadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Metadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Metadata, a, b); + } +}; +var EditorOptions = class _EditorOptions extends Message { + /** + * @generated from field: uint64 tab_size = 1; + */ + tabSize = protoInt64.zero; + /** + * @generated from field: bool insert_spaces = 2; + */ + insertSpaces = false; + /** + * @generated from field: bool disable_autocomplete_in_comments = 3; + */ + disableAutocompleteInComments = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.EditorOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'tab_size', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'insert_spaces', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'disable_autocomplete_in_comments', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _EditorOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _EditorOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _EditorOptions().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_EditorOptions, a, b); + } +}; +var ErrorTrace = class _ErrorTrace extends Message { + /** + * @generated from field: string error_id = 1; + */ + errorId = ''; + /** + * @generated from field: int64 timestamp_unix_ms = 2; + */ + timestampUnixMs = protoInt64.zero; + /** + * @generated from field: string stacktrace = 3; + */ + stacktrace = ''; + /** + * @generated from field: bool recovered = 4; + */ + recovered = false; + /** + * @generated from field: string full_stderr = 5; + */ + fullStderr = ''; + /** + * We don't include a full codeium_common.Metadata field to avoid + * the risk of leaking PII. Instead only include the field we need. + * + * @generated from field: string ide_name = 6; + */ + ideName = ''; + /** + * @generated from field: string ide_version = 7; + */ + ideVersion = ''; + /** + * @generated from field: string os = 8; + */ + os = ''; + /** + * @generated from field: bool is_dev = 9; + */ + isDev = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ErrorTrace'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'error_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'timestamp_unix_ms', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 3, + name: 'stacktrace', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'recovered', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'full_stderr', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'ide_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'ide_version', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'os', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'is_dev', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ErrorTrace().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ErrorTrace().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ErrorTrace().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ErrorTrace, a, b); + } +}; +var Event = class _Event extends Message { + /** + * @generated from field: exa.codeium_common_pb.EventType event_type = 1; + */ + eventType = EventType.UNSPECIFIED; + /** + * @generated from field: string event_json = 2; + */ + eventJson = ''; + /** + * @generated from field: int64 timestamp_unix_ms = 3; + */ + timestampUnixMs = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Event'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'event_type', + kind: 'enum', + T: proto3.getEnumType(EventType), + }, + { + no: 2, + name: 'event_json', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'timestamp_unix_ms', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _Event().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Event().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Event().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Event, a, b); + } +}; +var Citation = class _Citation extends Message { + /** + * The start index of the citation relative to the entire model generation + * This is in terms of bytes, assuming UTF-8 encoding + * + * @generated from field: int32 start_index = 1; + */ + startIndex = 0; + /** + * The end index of the citation relative to the entire model generation + * This is in terms of bytes, assuming UTF-8 encoding + * + * @generated from field: int32 end_index = 2; + */ + endIndex = 0; + /** + * The URI of the citation + * + * @generated from field: string uri = 3; + */ + uri = ''; + /** + * The title of the citation + * + * @generated from field: string title = 4; + */ + title = ''; + /** + * The license from the citation + * + * @generated from field: string license = 5; + */ + license = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Citation'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'start_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'end_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'license', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _Citation().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Citation().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Citation().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Citation, a, b); + } +}; +var CitationMetadata = class _CitationMetadata extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.Citation citations = 1; + */ + citations = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CitationMetadata'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'citations', kind: 'message', T: Citation, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _CitationMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CitationMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CitationMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CitationMetadata, a, b); + } +}; +var Recitation = class _Recitation extends Message { + /** + * The original citation metadata from Google Cloud AI Platform + * Note that the startIndex and endIndex fields in citation are relative to + * the entire model generation. + * + * @generated from field: exa.codeium_common_pb.Citation citation = 1; + */ + citation; + /** + * The actual content text that was cited + * + * @generated from field: string content = 2; + */ + content = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Recitation'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'citation', kind: 'message', T: Citation }, + { + no: 2, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _Recitation().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Recitation().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Recitation().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Recitation, a, b); + } +}; +var RecitationMetadata = class _RecitationMetadata extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.Recitation recitations = 1; + */ + recitations = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.RecitationMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'recitations', + kind: 'message', + T: Recitation, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _RecitationMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RecitationMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RecitationMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RecitationMetadata, a, b); + } +}; +var SearchResultRecord = class _SearchResultRecord extends Message { + /** + * UUID for each search query. + * + * @generated from field: string search_id = 1; + */ + searchId = ''; + /** + * UUID for each search result. + * + * @generated from field: string result_id = 2; + */ + resultId = ''; + /** + * @generated from field: string absolute_path = 3; + */ + absolutePath = ''; + /** + * @generated from field: repeated exa.codeium_common_pb.WorkspacePath workspace_paths = 4; + */ + workspacePaths = []; + /** + * The full text of the embedding match. + * + * @generated from field: string text = 5; + */ + text = ''; + /** + * @generated from field: exa.codeium_common_pb.EmbeddingMetadata embedding_metadata = 6; + */ + embeddingMetadata; + /** + * @generated from field: float similarity_score = 7; + */ + similarityScore = 0; + /** + * @generated from field: int64 num_results_in_cluster = 8; + */ + numResultsInCluster = protoInt64.zero; + /** + * @generated from field: string representative_path = 9; + */ + representativePath = ''; + /** + * @generated from field: float mean_similarity_score = 10; + */ + meanSimilarityScore = 0; + /** + * @generated from field: exa.codeium_common_pb.SearchResultType search_result_type = 11; + */ + searchResultType = SearchResultType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.SearchResultRecord'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'search_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'result_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'absolute_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'workspace_paths', + kind: 'message', + T: WorkspacePath, + repeated: true, + }, + { + no: 5, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'embedding_metadata', + kind: 'message', + T: EmbeddingMetadata, + }, + { + no: 7, + name: 'similarity_score', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 8, + name: 'num_results_in_cluster', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 9, + name: 'representative_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'mean_similarity_score', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 11, + name: 'search_result_type', + kind: 'enum', + T: proto3.getEnumType(SearchResultType), + }, + ]); + static fromBinary(bytes, options) { + return new _SearchResultRecord().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SearchResultRecord().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SearchResultRecord().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SearchResultRecord, a, b); + } +}; +var WorkspacePath = class _WorkspacePath extends Message { + /** + * Absolute path to root of the workspace. + * + * @generated from field: string workspace_migrate_me_to_uri = 1 [deprecated = true]; + * @deprecated + */ + workspaceMigrateMeToUri = ''; + /** + * @generated from field: string workspace_uri = 3; + */ + workspaceUri = ''; + /** + * Relative path to the search result file. + * + * @generated from field: string relative_path = 2; + */ + relativePath = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.WorkspacePath'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'workspace_migrate_me_to_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'workspace_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'relative_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _WorkspacePath().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WorkspacePath().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WorkspacePath().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_WorkspacePath, a, b); + } +}; +var EmbeddingMetadata = class _EmbeddingMetadata extends Message { + /** + * Name of search result node in the file. + * + * @generated from field: string node_name = 1; + */ + nodeName = ''; + /** + * Line in the file where the search result starts. Inclusive. + * + * @generated from field: uint32 start_line = 2; + */ + startLine = 0; + /** + * Line in the file where the search result ends. Inclusive. + * + * @generated from field: uint32 end_line = 3; + */ + endLine = 0; + /** + * Embed type of the search result. + * + * @generated from field: exa.codeium_common_pb.EmbedType embed_type = 4; + */ + embedType = EmbedType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.EmbeddingMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'node_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'start_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'end_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'embed_type', + kind: 'enum', + T: proto3.getEnumType(EmbedType), + }, + ]); + static fromBinary(bytes, options) { + return new _EmbeddingMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _EmbeddingMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _EmbeddingMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_EmbeddingMetadata, a, b); + } +}; +var MockResponseData = class _MockResponseData extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.Completion completions = 1; + */ + completions = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.MockResponseData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'completions', + kind: 'message', + T: Completion, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _MockResponseData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MockResponseData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MockResponseData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_MockResponseData, a, b); + } +}; +var WorkspaceIndexData = class _WorkspaceIndexData extends Message { + /** + * @generated from field: string workspace_uri_for_telemetry = 1; + */ + workspaceUriForTelemetry = ''; + /** + * @generated from field: google.protobuf.Timestamp indexing_start = 2; + */ + indexingStart; + /** + * @generated from field: google.protobuf.Timestamp indexing_end = 3; + */ + indexingEnd; + /** + * @generated from field: google.protobuf.Duration embedding_duration = 4; + */ + embeddingDuration; + /** + * @generated from field: int64 num_files_total = 5; + */ + numFilesTotal = protoInt64.zero; + /** + * @generated from field: int64 num_files_to_embed = 6; + */ + numFilesToEmbed = protoInt64.zero; + /** + * @generated from field: int64 num_nodes_total = 7; + */ + numNodesTotal = protoInt64.zero; + /** + * @generated from field: int64 num_nodes_to_embed = 8; + */ + numNodesToEmbed = protoInt64.zero; + /** + * @generated from field: int64 num_tokens = 9; + */ + numTokens = protoInt64.zero; + /** + * @generated from field: int64 num_high_priority_nodes_to_embed = 10; + */ + numHighPriorityNodesToEmbed = protoInt64.zero; + /** + * @generated from field: string error = 11; + */ + error = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.WorkspaceIndexData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'workspace_uri_for_telemetry', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'indexing_start', kind: 'message', T: Timestamp }, + { no: 3, name: 'indexing_end', kind: 'message', T: Timestamp }, + { no: 4, name: 'embedding_duration', kind: 'message', T: Duration }, + { + no: 5, + name: 'num_files_total', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 6, + name: 'num_files_to_embed', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 7, + name: 'num_nodes_total', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 8, + name: 'num_nodes_to_embed', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 9, + name: 'num_tokens', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 10, + name: 'num_high_priority_nodes_to_embed', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 11, + name: 'error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _WorkspaceIndexData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WorkspaceIndexData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WorkspaceIndexData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_WorkspaceIndexData, a, b); + } +}; +var WorkspaceStats = class _WorkspaceStats extends Message { + /** + * @generated from field: string workspace = 3; + */ + workspace = ''; + /** + * The keys are Languages. + * + * @generated from field: map num_files = 1; + */ + numFiles = {}; + /** + * The keys are Languages. + * + * @generated from field: map num_bytes = 2; + */ + numBytes = {}; + /** + * False if not all known files have been indexed, data may be incomplete. + * + * @generated from field: bool initial_scan_completed = 4; + */ + initialScanCompleted = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.WorkspaceStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 3, + name: 'workspace', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 1, + name: 'num_files', + kind: 'map', + K: 5, + V: { + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + }, + { + no: 2, + name: 'num_bytes', + kind: 'map', + K: 5, + V: { + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + }, + { + no: 4, + name: 'initial_scan_completed', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _WorkspaceStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WorkspaceStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WorkspaceStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_WorkspaceStats, a, b); + } +}; +var PartialIndexMetadata = class _PartialIndexMetadata extends Message { + /** + * @generated from field: uint32 num_total_files = 1; + */ + numTotalFiles = 0; + /** + * @generated from field: uint32 num_indexed_files = 2; + */ + numIndexedFiles = 0; + /** + * Denotes that files older than this timestamp are not indexed. + * + * @generated from field: google.protobuf.Timestamp cutoff_timestamp = 3; + */ + cutoffTimestamp; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PartialIndexMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'num_total_files', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'num_indexed_files', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 3, name: 'cutoff_timestamp', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _PartialIndexMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PartialIndexMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PartialIndexMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PartialIndexMetadata, a, b); + } +}; +var FunctionInfo = class _FunctionInfo extends Message { + /** + * @generated from field: string raw_source = 1; + */ + rawSource = ''; + /** + * @generated from field: string clean_function = 2; + */ + cleanFunction = ''; + /** + * @generated from field: string docstring = 3; + */ + docstring = ''; + /** + * @generated from field: string node_name = 4; + */ + nodeName = ''; + /** + * @generated from field: string params = 5; + */ + params = ''; + /** + * @generated from field: int32 definition_line = 6; + */ + definitionLine = 0; + /** + * 0-indexed (start & end). + * + * @generated from field: int32 start_line = 7; + */ + startLine = 0; + /** + * @generated from field: int32 end_line = 8; + */ + endLine = 0; + /** + * @generated from field: int32 start_col = 9; + */ + startCol = 0; + /** + * Exclusive of (end_line, end_col). + * + * @generated from field: int32 end_col = 10; + */ + endCol = 0; + /** + * @generated from field: string leading_whitespace = 11; + */ + leadingWhitespace = ''; + /** + * @generated from field: exa.codeium_common_pb.Language language = 12; + */ + language = Language.UNSPECIFIED; + /** + * @generated from field: int32 body_start_line = 13; + */ + bodyStartLine = 0; + /** + * @generated from field: int32 body_start_col = 14; + */ + bodyStartCol = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.FunctionInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'raw_source', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'clean_function', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'docstring', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'node_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'params', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'definition_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 7, + name: 'start_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 8, + name: 'end_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 9, + name: 'start_col', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 10, + name: 'end_col', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 11, + name: 'leading_whitespace', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 12, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { + no: 13, + name: 'body_start_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 14, + name: 'body_start_col', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _FunctionInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FunctionInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FunctionInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FunctionInfo, a, b); + } +}; +var ClassInfo = class _ClassInfo extends Message { + /** + * @generated from field: string raw_source = 1; + */ + rawSource = ''; + /** + * @generated from field: int32 start_line = 2; + */ + startLine = 0; + /** + * @generated from field: int32 end_line = 3; + */ + endLine = 0; + /** + * @generated from field: int32 start_col = 4; + */ + startCol = 0; + /** + * @generated from field: int32 end_col = 5; + */ + endCol = 0; + /** + * @generated from field: string leading_whitespace = 6; + */ + leadingWhitespace = ''; + /** + * @generated from field: repeated string fields_and_constructors = 7; + */ + fieldsAndConstructors = []; + /** + * @generated from field: string docstring = 8; + */ + docstring = ''; + /** + * @generated from field: string node_name = 9; + */ + nodeName = ''; + /** + * @generated from field: repeated exa.codeium_common_pb.FunctionInfo methods = 10; + */ + methods = []; + /** + * @generated from field: repeated string node_lineage = 11; + */ + nodeLineage = []; + /** + * @generated from field: bool is_exported = 12; + */ + isExported = false; + /** + * @generated from field: exa.codeium_common_pb.Language language = 13; + */ + language = Language.UNSPECIFIED; + /** + * @generated from field: int32 definition_line = 14; + */ + definitionLine = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ClassInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'raw_source', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'start_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'end_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'start_col', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'end_col', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'leading_whitespace', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'fields_and_constructors', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 8, + name: 'docstring', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'node_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'methods', + kind: 'message', + T: FunctionInfo, + repeated: true, + }, + { no: 11, name: 'node_lineage', kind: 'scalar', T: 9, repeated: true }, + { + no: 12, + name: 'is_exported', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 13, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { + no: 14, + name: 'definition_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ClassInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ClassInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ClassInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ClassInfo, a, b); + } +}; +var TeamsFeaturesMetadata = class _TeamsFeaturesMetadata extends Message { + /** + * Whether the feature is currently used by the team + * + * @generated from field: bool is_active = 1; + */ + isActive = false; + /** + * Stripe subscription ID for the feature if it's an add-on + * + * @generated from field: string stripe_subscription_id = 2; + */ + stripeSubscriptionId = ''; + /** + * Whether the team has access to the feature + * + * @generated from field: bool has_access = 3; + */ + hasAccess = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TeamsFeaturesMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'is_active', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'stripe_subscription_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'has_access', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _TeamsFeaturesMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TeamsFeaturesMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TeamsFeaturesMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TeamsFeaturesMetadata, a, b); + } +}; +var QuotaInfo = class _QuotaInfo extends Message { + /** + * @generated from field: float remaining_fraction = 1; + */ + remainingFraction = 0; + /** + * @generated from field: google.protobuf.Timestamp reset_time = 2; + */ + resetTime; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.QuotaInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'remaining_fraction', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { no: 2, name: 'reset_time', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _QuotaInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _QuotaInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _QuotaInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_QuotaInfo, a, b); + } +}; +var ClientModelConfig = class _ClientModelConfig extends Message { + /** + * Display name and used as a unique identifier + * + * @generated from field: string label = 1; + */ + label = ''; + /** + * @generated from field: exa.codeium_common_pb.ModelOrAlias model_or_alias = 2; + */ + modelOrAlias; + /** + * Multiplier applied to credits used for this model. + * Only applicable to MODEL_PRICING_TYPE_STATIC_CREDIT. + * + * @generated from field: float credit_multiplier = 3; + */ + creditMultiplier = 0; + /** + * Pricing type for this model. + * + * @generated from field: exa.codeium_common_pb.ModelPricingType pricing_type = 13; + */ + pricingType = ModelPricingType.UNSPECIFIED; + /** + * If true, the model is still rendered in the UI but is disabled. + * + * @generated from field: bool disabled = 4; + */ + disabled = false; + /** + * @generated from field: bool supports_images = 5; + */ + supportsImages = false; + /** + * If true, the model can be used in legacy mode. + * + * @generated from field: bool supports_legacy = 6; + */ + supportsLegacy = false; + /** + * If true, the model will be shown in the premium models section. + * + * @generated from field: bool is_premium = 7; + */ + isPremium = false; + /** + * A message to display when the model is beta. + * + * @generated from field: string beta_warning_message = 8; + */ + betaWarningMessage = ''; + /** + * If true, the model is beta. + * + * @generated from field: bool is_beta = 9; + */ + isBeta = false; + /** + * The provider of the model. + * + * @generated from field: exa.codeium_common_pb.ModelProvider provider = 10; + */ + provider = ModelProvider.UNSPECIFIED; + /** + * If true, the model is recommended to users. + * + * @generated from field: bool is_recommended = 11; + */ + isRecommended = false; + /** + * Allowed Tiers for Command Models + * + * @generated from field: repeated exa.codeium_common_pb.TeamsTier allowed_tiers = 12; + */ + allowedTiers = []; + /** + * Description that appears below the model label in the model selector. + * Should be short and concise. + * + * @generated from field: string description = 14; + */ + description = ''; + /** + * Quota information for this model, coming from go/quotaserver. + * + * @generated from field: exa.codeium_common_pb.QuotaInfo quota_info = 15; + */ + quotaInfo; + /** + * @generated from field: string tag_title = 16; + */ + tagTitle = ''; + /** + * @generated from field: string tag_description = 17; + */ + tagDescription = ''; + /** + * Map of MIME types to whether the model supports them. + * If this map is populated, it takes precedence over the individual boolean + * fields (supports_images, supports_pdf, supports_video). + * + * @generated from field: map supported_mime_types = 18; + */ + supportedMimeTypes = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ClientModelConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'label', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'model_or_alias', kind: 'message', T: ModelOrAlias }, + { + no: 3, + name: 'credit_multiplier', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 13, + name: 'pricing_type', + kind: 'enum', + T: proto3.getEnumType(ModelPricingType), + }, + { + no: 4, + name: 'disabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'supports_images', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'supports_legacy', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'is_premium', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 8, + name: 'beta_warning_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'is_beta', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 10, + name: 'provider', + kind: 'enum', + T: proto3.getEnumType(ModelProvider), + }, + { + no: 11, + name: 'is_recommended', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 12, + name: 'allowed_tiers', + kind: 'enum', + T: proto3.getEnumType(TeamsTier), + repeated: true, + }, + { + no: 14, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 15, name: 'quota_info', kind: 'message', T: QuotaInfo }, + { + no: 16, + name: 'tag_title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 17, + name: 'tag_description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 18, + name: 'supported_mime_types', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _ClientModelConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ClientModelConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ClientModelConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ClientModelConfig, a, b); + } +}; +var DefaultOverrideModelConfig = class _DefaultOverrideModelConfig extends Message { + /** + * The model to use as the default or override. + * + * @generated from field: exa.codeium_common_pb.ModelOrAlias model_or_alias = 1; + */ + modelOrAlias; + /** + * Version to differentiate when the client should override or keep last + * selected user model. + * + * @generated from field: string version_id = 2; + */ + versionId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DefaultOverrideModelConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'model_or_alias', kind: 'message', T: ModelOrAlias }, + { + no: 2, + name: 'version_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _DefaultOverrideModelConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DefaultOverrideModelConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DefaultOverrideModelConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_DefaultOverrideModelConfig, a, b); + } +}; +var ClientModelSort = class _ClientModelSort extends Message { + /** + * Name of the sort within the Cascade model selector (e.g. "Recommended", + * "Provider", "Cost"). + * + * @generated from field: string name = 1; + */ + name = ''; + /** + * Groups of models within this sort. + * + * @generated from field: repeated exa.codeium_common_pb.ClientModelGroup groups = 2; + */ + groups = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ClientModelSort'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'groups', + kind: 'message', + T: ClientModelGroup, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ClientModelSort().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ClientModelSort().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ClientModelSort().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ClientModelSort, a, b); + } +}; +var ClientModelGroup = class _ClientModelGroup extends Message { + /** + * Name of the group in a ClientModelSort. Can be empty if sort is ungrouped + * (e.g. "Recommended" sort). + * + * @generated from field: string group_name = 1; + */ + groupName = ''; + /** + * List of model labels in this group. + * + * @generated from field: repeated string model_labels = 2; + */ + modelLabels = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ClientModelGroup'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'group_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'model_labels', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _ClientModelGroup().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ClientModelGroup().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ClientModelGroup().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ClientModelGroup, a, b); + } +}; +var CascadeModelConfigData = class _CascadeModelConfigData extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.ClientModelConfig client_model_configs = 1; + */ + clientModelConfigs = []; + /** + * @generated from field: repeated exa.codeium_common_pb.ClientModelSort client_model_sorts = 2; + */ + clientModelSorts = []; + /** + * @generated from field: optional exa.codeium_common_pb.DefaultOverrideModelConfig default_override_model_config = 3; + */ + defaultOverrideModelConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CascadeModelConfigData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'client_model_configs', + kind: 'message', + T: ClientModelConfig, + repeated: true, + }, + { + no: 2, + name: 'client_model_sorts', + kind: 'message', + T: ClientModelSort, + repeated: true, + }, + { + no: 3, + name: 'default_override_model_config', + kind: 'message', + T: DefaultOverrideModelConfig, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeModelConfigData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeModelConfigData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeModelConfigData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadeModelConfigData, a, b); + } +}; +var AllowedModelConfig = class _AllowedModelConfig extends Message { + /** + * @generated from field: exa.codeium_common_pb.ModelOrAlias model_or_alias = 1; + */ + modelOrAlias; + /** + * @generated from field: float credit_multiplier = 2; + */ + creditMultiplier = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.AllowedModelConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'model_or_alias', kind: 'message', T: ModelOrAlias }, + { + no: 2, + name: 'credit_multiplier', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + ]); + static fromBinary(bytes, options) { + return new _AllowedModelConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AllowedModelConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AllowedModelConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AllowedModelConfig, a, b); + } +}; +var PlanInfo = class _PlanInfo extends Message { + /** + * If the user is not on a team, this will be UNSPECIFIED. + * + * @generated from field: exa.codeium_common_pb.TeamsTier teams_tier = 1; + */ + teamsTier = TeamsTier.UNSPECIFIED; + /** + * Human readable name of the plan to display to the user. + * + * @generated from field: string plan_name = 2; + */ + planName = ''; + /** + * Boolean feature gates + * + * @generated from field: bool has_autocomplete_fast_mode = 3; + */ + hasAutocompleteFastMode = false; + /** + * @generated from field: bool allow_sticky_premium_models = 4; + */ + allowStickyPremiumModels = false; + /** + * @generated from field: bool has_forge_access = 5; + */ + hasForgeAccess = false; + /** + * @generated from field: bool disable_code_snippet_telemetry = 11; + */ + disableCodeSnippetTelemetry = false; + /** + * @generated from field: bool allow_premium_command_models = 15; + */ + allowPremiumCommandModels = false; + /** + * @generated from field: bool has_tab_to_jump = 23; + */ + hasTabToJump = false; + /** + * Feature limits & quotas. A value of -1 would indicate unlimited. + * + * @generated from field: int64 max_num_premium_chat_messages = 6; + */ + maxNumPremiumChatMessages = protoInt64.zero; + /** + * Limit on the number of tokens in a user's chat message. + * + * @generated from field: int64 max_num_chat_input_tokens = 7; + */ + maxNumChatInputTokens = protoInt64.zero; + /** + * @generated from field: int64 max_custom_chat_instruction_characters = 8; + */ + maxCustomChatInstructionCharacters = protoInt64.zero; + /** + * @generated from field: int64 max_num_pinned_context_items = 9; + */ + maxNumPinnedContextItems = protoInt64.zero; + /** + * @generated from field: int64 max_local_index_size = 10; + */ + maxLocalIndexSize = protoInt64.zero; + /** + * Maximum number of unclaimed sites for Antigravity deployments a user can + * have based on their plan. This field is deprecated; and moved into + * TeamConfig instead. + * + * @generated from field: int32 max_unclaimed_sites = 26 [deprecated = true]; + * @deprecated + */ + maxUnclaimedSites = 0; + /** + * @generated from field: int32 monthly_prompt_credits = 12; + */ + monthlyPromptCredits = 0; + /** + * @generated from field: int32 monthly_flow_credits = 13; + */ + monthlyFlowCredits = 0; + /** + * @generated from field: int32 monthly_flex_credit_purchase_amount = 14; + */ + monthlyFlexCreditPurchaseAmount = 0; + /** + * Properties of the Plan + * If the plan allows multiple users. + * + * @generated from field: bool is_teams = 17; + */ + isTeams = false; + /** + * If the plan is enterprise. + * + * @generated from field: bool is_enterprise = 16; + */ + isEnterprise = false; + /** + * Only users with a paid plan can purchase more credits. Free/trial will need + * to upgrade first. + * + * @generated from field: bool can_buy_more_credits = 18; + */ + canBuyMoreCredits = false; + /** + * Whether the user has web search enabled (enterprise admins have the option + * to enable or disable it). + * + * @generated from field: bool cascade_web_search_enabled = 19; + */ + cascadeWebSearchEnabled = false; + /** + * Whether we permit the user to customize their app icon. + * + * @generated from field: bool can_customize_app_icon = 20; + */ + canCustomizeAppIcon = false; + /** + * Whether the user can enable Cascade to automatically run commands. + * + * @generated from field: bool cascade_can_auto_run_commands = 22; + */ + cascadeCanAutoRunCommands = false; + /** + * Whether the user can use the AI-generated commit message feature. + * + * @generated from field: bool can_generate_commit_messages = 25; + */ + canGenerateCommitMessages = false; + /** + * Whether the knowledge base feature is enabled for this user. + * + * @generated from field: bool knowledge_base_enabled = 27; + */ + knowledgeBaseEnabled = false; + /** + * List of models this user is allowed to use and their credit multipliers. + * + * @generated from field: repeated exa.codeium_common_pb.AllowedModelConfig cascade_allowed_models_config = 21 [deprecated = true]; + * @deprecated + */ + cascadeAllowedModelsConfig = []; + /** + * @generated from field: exa.codeium_common_pb.TeamConfig default_team_config = 24; + */ + defaultTeamConfig; + /** + * Whether the user can share conversations. + * + * @generated from field: bool can_share_conversations = 28; + */ + canShareConversations = false; + /** + * Whether the user can allow Cascade to run in the background. + * + * @generated from field: bool can_allow_cascade_in_background = 29; + */ + canAllowCascadeInBackground = false; + /** + * Map of team features that are enabled by default for this plan + * Key is the int32 value of TeamsFeatures enum, value is whether it's enabled + * + * @generated from field: map default_team_features = 30; + */ + defaultTeamFeatures = {}; + /** + * Whether the user can access Browser. + * + * @generated from field: bool browser_enabled = 31; + */ + browserEnabled = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PlanInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'teams_tier', + kind: 'enum', + T: proto3.getEnumType(TeamsTier), + }, + { + no: 2, + name: 'plan_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'has_autocomplete_fast_mode', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'allow_sticky_premium_models', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'has_forge_access', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 11, + name: 'disable_code_snippet_telemetry', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 15, + name: 'allow_premium_command_models', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 23, + name: 'has_tab_to_jump', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'max_num_premium_chat_messages', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 7, + name: 'max_num_chat_input_tokens', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 8, + name: 'max_custom_chat_instruction_characters', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 9, + name: 'max_num_pinned_context_items', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 10, + name: 'max_local_index_size', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 26, + name: 'max_unclaimed_sites', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 12, + name: 'monthly_prompt_credits', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 13, + name: 'monthly_flow_credits', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 14, + name: 'monthly_flex_credit_purchase_amount', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 17, + name: 'is_teams', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 16, + name: 'is_enterprise', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 18, + name: 'can_buy_more_credits', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 19, + name: 'cascade_web_search_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 20, + name: 'can_customize_app_icon', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 22, + name: 'cascade_can_auto_run_commands', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 25, + name: 'can_generate_commit_messages', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 27, + name: 'knowledge_base_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 21, + name: 'cascade_allowed_models_config', + kind: 'message', + T: AllowedModelConfig, + repeated: true, + }, + { no: 24, name: 'default_team_config', kind: 'message', T: TeamConfig }, + { + no: 28, + name: 'can_share_conversations', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 29, + name: 'can_allow_cascade_in_background', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 30, + name: 'default_team_features', + kind: 'map', + K: 5, + V: { kind: 'message', T: TeamsFeaturesMetadata }, + }, + { + no: 31, + name: 'browser_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _PlanInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PlanInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PlanInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PlanInfo, a, b); + } +}; +var TopUpStatus = class _TopUpStatus extends Message { + /** + * @generated from field: exa.codeium_common_pb.TransactionStatus top_up_transaction_status = 1; + */ + topUpTransactionStatus = TransactionStatus.UNSPECIFIED; + /** + * @generated from field: bool top_up_enabled = 2; + */ + topUpEnabled = false; + /** + * @generated from field: int32 monthly_top_up_amount = 3; + */ + monthlyTopUpAmount = 0; + /** + * @generated from field: int32 top_up_spent = 4; + */ + topUpSpent = 0; + /** + * @generated from field: int32 top_up_increment = 5; + */ + topUpIncrement = 0; + /** + * @generated from field: bool top_up_criteria_met = 6; + */ + topUpCriteriaMet = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TopUpStatus'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'top_up_transaction_status', + kind: 'enum', + T: proto3.getEnumType(TransactionStatus), + }, + { + no: 2, + name: 'top_up_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'monthly_top_up_amount', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'top_up_spent', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'top_up_increment', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'top_up_criteria_met', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _TopUpStatus().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TopUpStatus().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TopUpStatus().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TopUpStatus, a, b); + } +}; +var PlanStatus = class _PlanStatus extends Message { + /** + * @generated from field: exa.codeium_common_pb.PlanInfo plan_info = 1; + */ + planInfo; + /** + * @generated from field: google.protobuf.Timestamp plan_start = 2; + */ + planStart; + /** + * @generated from field: google.protobuf.Timestamp plan_end = 3; + */ + planEnd; + /** + * All credits will return in cents. (ie 1 flow usage uses 100 credits). + * + * @generated from field: int32 available_prompt_credits = 8; + */ + availablePromptCredits = 0; + /** + * Available flow credits = monthly flow credits * # users. + * + * @generated from field: int32 available_flow_credits = 9; + */ + availableFlowCredits = 0; + /** + * @generated from field: int32 available_flex_credits = 4; + */ + availableFlexCredits = 0; + /** + * @generated from field: int32 used_flex_credits = 7; + */ + usedFlexCredits = 0; + /** + * @generated from field: int32 used_flow_credits = 5; + */ + usedFlowCredits = 0; + /** + * @generated from field: int32 used_prompt_credits = 6; + */ + usedPromptCredits = 0; + /** + * @generated from field: exa.codeium_common_pb.TopUpStatus top_up_status = 10; + */ + topUpStatus; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PlanStatus'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'plan_info', kind: 'message', T: PlanInfo }, + { no: 2, name: 'plan_start', kind: 'message', T: Timestamp }, + { no: 3, name: 'plan_end', kind: 'message', T: Timestamp }, + { + no: 8, + name: 'available_prompt_credits', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 9, + name: 'available_flow_credits', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'available_flex_credits', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 7, + name: 'used_flex_credits', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'used_flow_credits', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'used_prompt_credits', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { no: 10, name: 'top_up_status', kind: 'message', T: TopUpStatus }, + ]); + static fromBinary(bytes, options) { + return new _PlanStatus().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PlanStatus().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PlanStatus().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PlanStatus, a, b); + } +}; +var UserStatus = class _UserStatus extends Message { + /** + * @generated from field: bool pro = 1; + */ + pro = false; + /** + * Whether the user has opted out of code-snippet telemetry. Note that this is + * separate from disabling telemetry at an IDE level. + * + * @generated from field: bool disable_telemetry = 2; + */ + disableTelemetry = false; + /** + * @generated from field: string name = 3; + */ + name = ''; + /** + * @generated from field: bool ignore_chat_telemetry_setting = 4; + */ + ignoreChatTelemetrySetting = false; + /** + * WARNING: naming is a bit misleading (for legacy reasons). If this field is + * nonempty, then the user is a paid user. This is separate from the Teams + * plan tier; see the isTeams field on PlanInfo. + * + * @generated from field: string team_id = 5; + */ + teamId = ''; + /** + * @generated from field: exa.codeium_common_pb.UserTeamStatus team_status = 6; + */ + teamStatus = UserTeamStatus.UNSPECIFIED; + /** + * @generated from field: string email = 7; + */ + email = ''; + /** + * @generated from field: repeated exa.codeium_common_pb.UserFeatures user_features = 9; + */ + userFeatures = []; + /** + * Only applicable if user is approved in a valid team. + * + * @generated from field: repeated exa.codeium_common_pb.TeamsFeatures teams_features = 8; + */ + teamsFeatures = []; + /** + * @generated from field: repeated exa.codeium_common_pb.Permission permissions = 11; + */ + permissions = []; + /** + * TODO(nmoy, wliu): remove plan_info since it's now inside PlanStatus + * + * @generated from field: exa.codeium_common_pb.PlanInfo plan_info = 12 [deprecated = true]; + * @deprecated + */ + planInfo; + /** + * @generated from field: exa.codeium_common_pb.PlanStatus plan_status = 13; + */ + planStatus; + /** + * @generated from field: bool has_used_antigravity = 31; + */ + hasUsedAntigravity = false; + /** + * All credits will return in cents. (ie 1 flow usage uses 100 credits). + * + * @generated from field: int64 user_used_prompt_credits = 28; + */ + userUsedPromptCredits = protoInt64.zero; + /** + * @generated from field: int64 user_used_flow_credits = 29; + */ + userUsedFlowCredits = protoInt64.zero; + /** + * @generated from field: bool has_fingerprint_set = 30; + */ + hasFingerprintSet = false; + /** + * @generated from field: exa.codeium_common_pb.TeamConfig team_config = 32; + */ + teamConfig; + /** + * Model configuration data consolidated from getCascadeModelConfigs + * + * @generated from field: exa.codeium_common_pb.CascadeModelConfigData cascade_model_config_data = 33; + */ + cascadeModelConfigData; + /** + * Whether the user has accepted the latest terms of service. + * + * @generated from field: bool accepted_latest_terms_of_service = 34; + */ + acceptedLatestTermsOfService = false; + /** + * The G1 tier of the user. + * + * @generated from field: string g1_tier = 35 [deprecated = true]; + * @deprecated + */ + g1Tier = ''; + /** + * The Google UserTier object from onboarding.proto + * + * @generated from field: google.internal.cloud.code.v1internal.UserTier user_tier = 36; + */ + userTier; + /** + * Whether data collection is force disabled for this user. + * + * @generated from field: bool user_data_collection_force_disabled = 37; + */ + userDataCollectionForceDisabled = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.UserStatus'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'pro', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'disable_telemetry', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'ignore_chat_telemetry_setting', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'team_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'team_status', + kind: 'enum', + T: proto3.getEnumType(UserTeamStatus), + }, + { + no: 7, + name: 'email', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'user_features', + kind: 'enum', + T: proto3.getEnumType(UserFeatures), + repeated: true, + }, + { + no: 8, + name: 'teams_features', + kind: 'enum', + T: proto3.getEnumType(TeamsFeatures), + repeated: true, + }, + { + no: 11, + name: 'permissions', + kind: 'enum', + T: proto3.getEnumType(Permission), + repeated: true, + }, + { no: 12, name: 'plan_info', kind: 'message', T: PlanInfo }, + { no: 13, name: 'plan_status', kind: 'message', T: PlanStatus }, + { + no: 31, + name: 'has_used_antigravity', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 28, + name: 'user_used_prompt_credits', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 29, + name: 'user_used_flow_credits', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 30, + name: 'has_fingerprint_set', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 32, name: 'team_config', kind: 'message', T: TeamConfig }, + { + no: 33, + name: 'cascade_model_config_data', + kind: 'message', + T: CascadeModelConfigData, + }, + { + no: 34, + name: 'accepted_latest_terms_of_service', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 35, + name: 'g1_tier', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 36, name: 'user_tier', kind: 'message', T: UserTier }, + { + no: 37, + name: 'user_data_collection_force_disabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _UserStatus().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserStatus().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserStatus().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserStatus, a, b); + } +}; +var ScmWorkspaceInfo = class _ScmWorkspaceInfo extends Message { + /** + * @generated from oneof exa.codeium_common_pb.ScmWorkspaceInfo.info + */ + info = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ScmWorkspaceInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'perforce_info', + kind: 'message', + T: PerforceDepotInfo, + oneof: 'info', + }, + { no: 2, name: 'git_info', kind: 'message', T: GitRepoInfo, oneof: 'info' }, + ]); + static fromBinary(bytes, options) { + return new _ScmWorkspaceInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ScmWorkspaceInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ScmWorkspaceInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ScmWorkspaceInfo, a, b); + } +}; +var PerforceDepotInfo = class _PerforceDepotInfo extends Message { + /** + * Unique name of the repository, commonly //depot/project. + * + * @generated from field: string depot_name = 1; + */ + depotName = ''; + /** + * Optional name to identify the version of this repo. + * + * @generated from field: string version_alias = 2; + */ + versionAlias = ''; + /** + * e.g p4d://host:port + * + * @generated from field: string base_p4d_url = 3; + */ + baseP4dUrl = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PerforceDepotInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'depot_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'version_alias', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'base_p4d_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _PerforceDepotInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PerforceDepotInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PerforceDepotInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PerforceDepotInfo, a, b); + } +}; +var GitRepoInfo = class _GitRepoInfo extends Message { + /** + * Prefer using repo_name. + * + * @generated from field: string name = 1; + */ + name = ''; + /** + * @generated from field: string owner = 2; + */ + owner = ''; + /** + * Unique name of the repository, commonly owner/name. + * + * @generated from field: string repo_name = 5; + */ + repoName = ''; + /** + * @generated from field: string commit = 3; + */ + commit = ''; + /** + * Optional name to identify the version of this repo. + * + * @generated from field: string version_alias = 4; + */ + versionAlias = ''; + /** + * @generated from field: exa.codeium_common_pb.ScmProvider scm_provider = 6; + */ + scmProvider = ScmProvider.UNSPECIFIED; + /** + * e.g https://github.com/ or https://gitent.exafunction.com/ + * + * @generated from field: string base_git_url = 7; + */ + baseGitUrl = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.GitRepoInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'owner', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'commit', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'version_alias', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'scm_provider', + kind: 'enum', + T: proto3.getEnumType(ScmProvider), + }, + { + no: 7, + name: 'base_git_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _GitRepoInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GitRepoInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GitRepoInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GitRepoInfo, a, b); + } +}; +var CodeContextItem = class _CodeContextItem extends Message { + /** + * Absolute path to file this CodeContextItem belongs to. + * + * @generated from field: string absolute_path_migrate_me_to_uri = 1 [deprecated = true]; + * @deprecated + */ + absolutePathMigrateMeToUri = ''; + /** + * @generated from field: string absolute_uri = 16; + */ + absoluteUri = ''; + /** + * Path relative to workspace roots. CodeContextItem may not always be within + * a workspace. + * + * @generated from field: repeated exa.codeium_common_pb.WorkspacePath workspace_paths = 2; + */ + workspacePaths = []; + /** + * Name of node in the file. + * + * @generated from field: string node_name = 3; + */ + nodeName = ''; + /** + * List of parent nodes in descending order. + * + * @generated from field: repeated string node_lineage = 4; + */ + nodeLineage = []; + /** + * 0-indexed (everything). + * Line in the file where the CodeContextItem starts. Inclusive. + * + * @generated from field: uint32 start_line = 5; + */ + startLine = 0; + /** + * Col in the file where the CodeContextItem starts. Inclusive. + * + * @generated from field: uint32 start_col = 12; + */ + startCol = 0; + /** + * Line in the file where the CodeContextItem ends. Inclusive. + * + * @generated from field: uint32 end_line = 6; + */ + endLine = 0; + /** + * Col in the file where the CodeContextItem ends. Exclusive. + * + * @generated from field: uint32 end_col = 13; + */ + endCol = 0; + /** + * What kind of code snippet it is. + * + * @generated from field: exa.codeium_common_pb.CodeContextType context_type = 7; + */ + contextType = CodeContextType.UNSPECIFIED; + /** + * Language. + * + * @generated from field: exa.codeium_common_pb.Language language = 10; + */ + language = Language.UNSPECIFIED; + /** + * A map for each ContextSnippetType representation of this CodeContextItem to + * a SnippetWithWordcount item. + * + * @generated from field: map snippet_by_type = 11; + */ + snippetByType = {}; + /** + * Only populated if code context item is retrieved from remote index. + * + * @generated from field: exa.codeium_common_pb.GitRepoInfo repo_info = 14; + */ + repoInfo; + /** + * MD5 sum of the file contents that this code context item belongs to. + * + * @generated from field: bytes file_content_hash = 15; + */ + fileContentHash = new Uint8Array(0); + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CodeContextItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_path_migrate_me_to_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 16, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'workspace_paths', + kind: 'message', + T: WorkspacePath, + repeated: true, + }, + { + no: 3, + name: 'node_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'node_lineage', kind: 'scalar', T: 9, repeated: true }, + { + no: 5, + name: 'start_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 12, + name: 'start_col', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 6, + name: 'end_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 13, + name: 'end_col', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 7, + name: 'context_type', + kind: 'enum', + T: proto3.getEnumType(CodeContextType), + }, + { no: 10, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { + no: 11, + name: 'snippet_by_type', + kind: 'map', + K: 9, + V: { kind: 'message', T: SnippetWithWordCount }, + }, + { no: 14, name: 'repo_info', kind: 'message', T: GitRepoInfo }, + { + no: 15, + name: 'file_content_hash', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + ]); + static fromBinary(bytes, options) { + return new _CodeContextItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeContextItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeContextItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeContextItem, a, b); + } +}; +var SnippetWithWordCount = class _SnippetWithWordCount extends Message { + /** + * @generated from field: string snippet = 1; + */ + snippet = ''; + /** + * There is one word count per Word Splitter type, where a Word Splitter is a + * particular algorithm for breaking a string into "words". + * + * @generated from field: map word_count_by_splitter = 2; + */ + wordCountBySplitter = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.SnippetWithWordCount'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'snippet', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'word_count_by_splitter', + kind: 'map', + K: 9, + V: { kind: 'message', T: WordCount }, + }, + ]); + static fromBinary(bytes, options) { + return new _SnippetWithWordCount().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SnippetWithWordCount().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SnippetWithWordCount().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SnippetWithWordCount, a, b); + } +}; +var WordCount = class _WordCount extends Message { + /** + * @generated from field: map word_count_map = 1; + */ + wordCountMap = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.WordCount'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'word_count_map', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _WordCount().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WordCount().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WordCount().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_WordCount, a, b); + } +}; +var Repository = class _Repository extends Message { + /** + * @generated from field: string computed_name = 1; + */ + computedName = ''; + /** + * @generated from field: string git_origin_url = 2; + */ + gitOriginUrl = ''; + /** + * @generated from field: string git_upstream_url = 3; + */ + gitUpstreamUrl = ''; + /** + * @generated from field: string reported_name = 4; + */ + reportedName = ''; + /** + * @generated from field: string model_name = 5; + */ + modelName = ''; + /** + * @generated from field: string submodule_url = 6; + */ + submoduleUrl = ''; + /** + * @generated from field: string submodule_path = 7; + */ + submodulePath = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Repository'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'computed_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'git_origin_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'git_upstream_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'reported_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'submodule_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'submodule_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _Repository().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Repository().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Repository().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Repository, a, b); + } +}; +var CaptureFileRequestData = class _CaptureFileRequestData extends Message { + /** + * @generated from field: exa.codeium_common_pb.Metadata metadata = 1; + */ + metadata; + /** + * @generated from field: string prompt_id = 2; + */ + promptId = ''; + /** + * absolute file path. + * + * @generated from field: string file_path = 3; + */ + filePath = ''; + /** + * @generated from field: string original_file_content = 4; + */ + originalFileContent = ''; + /** + * @generated from field: string completion_text = 5; + */ + completionText = ''; + /** + * start of replacement range for completion (measured in bytes). + * + * @generated from field: uint64 start_offset = 6; + */ + startOffset = protoInt64.zero; + /** + * start of replacement range for completion (measured in bytes). + * + * @generated from field: uint64 end_offset = 7; + */ + endOffset = protoInt64.zero; + /** + * what line the cursor is on. + * + * @generated from field: uint64 cursor_line = 8; + */ + cursorLine = protoInt64.zero; + /** + * which column within that line is the cursor on. + * + * @generated from field: uint64 cursor_column = 9; + */ + cursorColumn = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CaptureFileRequestData'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: Metadata }, + { + no: 2, + name: 'prompt_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'file_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'original_file_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'completion_text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'start_offset', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 7, + name: 'end_offset', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 8, + name: 'cursor_line', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 9, + name: 'cursor_column', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CaptureFileRequestData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CaptureFileRequestData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CaptureFileRequestData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CaptureFileRequestData, a, b); + } +}; +var CompletionStatistics = class _CompletionStatistics extends Message { + /** + * @generated from field: uint32 num_acceptances = 1; + */ + numAcceptances = 0; + /** + * @generated from field: uint32 num_rejections = 2; + */ + numRejections = 0; + /** + * @generated from field: uint32 num_lines_accepted = 3; + */ + numLinesAccepted = 0; + /** + * @generated from field: uint32 num_bytes_accepted = 4; + */ + numBytesAccepted = 0; + /** + * @generated from field: uint32 num_users = 5; + */ + numUsers = 0; + /** + * The total number of days spent using the tool across all developers during + * the period. + * + * @generated from field: uint32 active_developer_days = 6; + */ + activeDeveloperDays = 0; + /** + * The total number of hours spent using the tool across all developers during + * the period. + * + * @generated from field: uint32 active_developer_hours = 7; + */ + activeDeveloperHours = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionStatistics'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'num_acceptances', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'num_rejections', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'num_lines_accepted', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'num_bytes_accepted', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'num_users', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 6, + name: 'active_developer_days', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 7, + name: 'active_developer_hours', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionStatistics().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionStatistics().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionStatistics().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionStatistics, a, b); + } +}; +var CompletionByDateEntry = class _CompletionByDateEntry extends Message { + /** + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp; + /** + * @generated from field: exa.codeium_common_pb.CompletionStatistics completion_statistics = 2; + */ + completionStatistics; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionByDateEntry'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'timestamp', kind: 'message', T: Timestamp }, + { + no: 2, + name: 'completion_statistics', + kind: 'message', + T: CompletionStatistics, + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionByDateEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionByDateEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionByDateEntry().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionByDateEntry, a, b); + } +}; +var CompletionByLanguageEntry = class _CompletionByLanguageEntry extends Message { + /** + * @generated from field: exa.codeium_common_pb.Language language = 1; + */ + language = Language.UNSPECIFIED; + /** + * @generated from field: exa.codeium_common_pb.CompletionStatistics completion_statistics = 2; + */ + completionStatistics; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionByLanguageEntry'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { + no: 2, + name: 'completion_statistics', + kind: 'message', + T: CompletionStatistics, + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionByLanguageEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionByLanguageEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionByLanguageEntry().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionByLanguageEntry, a, b); + } +}; +var ChatStats = class _ChatStats extends Message { + /** + * @generated from field: uint64 chats_sent = 1; + */ + chatsSent = protoInt64.zero; + /** + * @generated from field: uint64 chats_received = 2; + */ + chatsReceived = protoInt64.zero; + /** + * @generated from field: uint64 chats_accepted = 3; + */ + chatsAccepted = protoInt64.zero; + /** + * @generated from field: uint64 chats_inserted_at_cursor = 4; + */ + chatsInsertedAtCursor = protoInt64.zero; + /** + * @generated from field: uint64 chats_applied = 5; + */ + chatsApplied = protoInt64.zero; + /** + * loc = lines of code + * + * @generated from field: uint64 chat_loc_used = 6; + */ + chatLocUsed = protoInt64.zero; + /** + * @generated from field: uint64 chat_code_blocks_used = 7; + */ + chatCodeBlocksUsed = protoInt64.zero; + /** + * @generated from field: uint64 function_explain_count = 8; + */ + functionExplainCount = protoInt64.zero; + /** + * @generated from field: uint64 function_docstring_count = 9; + */ + functionDocstringCount = protoInt64.zero; + /** + * @generated from field: uint64 function_refactor_count = 10; + */ + functionRefactorCount = protoInt64.zero; + /** + * @generated from field: uint64 code_block_explain_count = 11; + */ + codeBlockExplainCount = protoInt64.zero; + /** + * @generated from field: uint64 code_block_refactor_count = 12; + */ + codeBlockRefactorCount = protoInt64.zero; + /** + * @generated from field: uint64 problem_explain_count = 13; + */ + problemExplainCount = protoInt64.zero; + /** + * @generated from field: uint64 function_unit_tests_count = 14; + */ + functionUnitTestsCount = protoInt64.zero; + /** + * The total number of days spent using the tool across all developers during + * the period. + * + * @generated from field: uint32 active_developer_days = 15; + */ + activeDeveloperDays = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ChatStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'chats_sent', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'chats_received', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'chats_accepted', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 4, + name: 'chats_inserted_at_cursor', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 5, + name: 'chats_applied', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 6, + name: 'chat_loc_used', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 7, + name: 'chat_code_blocks_used', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 8, + name: 'function_explain_count', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 9, + name: 'function_docstring_count', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 10, + name: 'function_refactor_count', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 11, + name: 'code_block_explain_count', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 12, + name: 'code_block_refactor_count', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 13, + name: 'problem_explain_count', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 14, + name: 'function_unit_tests_count', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 15, + name: 'active_developer_days', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatStats, a, b); + } +}; +var ChatStatsByDateEntry = class _ChatStatsByDateEntry extends Message { + /** + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp; + /** + * @generated from field: exa.codeium_common_pb.ChatStats chat_stats = 2; + */ + chatStats; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ChatStatsByDateEntry'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'timestamp', kind: 'message', T: Timestamp }, + { no: 2, name: 'chat_stats', kind: 'message', T: ChatStats }, + ]); + static fromBinary(bytes, options) { + return new _ChatStatsByDateEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatStatsByDateEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatStatsByDateEntry().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatStatsByDateEntry, a, b); + } +}; +var ChatStatsByModelEntry = class _ChatStatsByModelEntry extends Message { + /** + * @generated from field: exa.codeium_common_pb.Model model_id = 1; + */ + modelId = Model.UNSPECIFIED; + /** + * @generated from field: exa.codeium_common_pb.ChatStats chat_stats = 2; + */ + chatStats; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ChatStatsByModelEntry'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'model_id', kind: 'enum', T: proto3.getEnumType(Model) }, + { no: 2, name: 'chat_stats', kind: 'message', T: ChatStats }, + ]); + static fromBinary(bytes, options) { + return new _ChatStatsByModelEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatStatsByModelEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatStatsByModelEntry().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatStatsByModelEntry, a, b); + } +}; +var CommandStats = class _CommandStats extends Message { + /** + * @generated from field: uint64 num_commands = 1; + */ + numCommands = protoInt64.zero; + /** + * @generated from field: uint64 num_commands_accepted = 2; + */ + numCommandsAccepted = protoInt64.zero; + /** + * @generated from field: uint64 num_commands_rejected = 3; + */ + numCommandsRejected = protoInt64.zero; + /** + * @generated from field: uint64 num_edits = 4; + */ + numEdits = protoInt64.zero; + /** + * @generated from field: uint64 num_generations = 5; + */ + numGenerations = protoInt64.zero; + /** + * @generated from field: uint64 loc_added = 6; + */ + locAdded = protoInt64.zero; + /** + * @generated from field: uint64 loc_removed = 7; + */ + locRemoved = protoInt64.zero; + /** + * @generated from field: uint64 bytes_added = 8; + */ + bytesAdded = protoInt64.zero; + /** + * @generated from field: uint64 bytes_removed = 9; + */ + bytesRemoved = protoInt64.zero; + /** + * @generated from field: uint64 loc_selected = 10; + */ + locSelected = protoInt64.zero; + /** + * @generated from field: uint64 bytes_selected = 11; + */ + bytesSelected = protoInt64.zero; + /** + * @generated from field: map num_commands_by_source = 12; + */ + numCommandsBySource = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CommandStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'num_commands', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'num_commands_accepted', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'num_commands_rejected', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 4, + name: 'num_edits', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 5, + name: 'num_generations', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 6, + name: 'loc_added', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 7, + name: 'loc_removed', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 8, + name: 'bytes_added', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 9, + name: 'bytes_removed', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 10, + name: 'loc_selected', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 11, + name: 'bytes_selected', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 12, + name: 'num_commands_by_source', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _CommandStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CommandStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CommandStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CommandStats, a, b); + } +}; +var CommandStatsByDateEntry = class _CommandStatsByDateEntry extends Message { + /** + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp; + /** + * @generated from field: exa.codeium_common_pb.CommandStats command_stats = 2; + */ + commandStats; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CommandStatsByDateEntry'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'timestamp', kind: 'message', T: Timestamp }, + { no: 2, name: 'command_stats', kind: 'message', T: CommandStats }, + ]); + static fromBinary(bytes, options) { + return new _CommandStatsByDateEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CommandStatsByDateEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CommandStatsByDateEntry().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CommandStatsByDateEntry, a, b); + } +}; +var UserTableStats = class _UserTableStats extends Message { + /** + * @generated from field: string name = 1; + */ + name = ''; + /** + * @generated from field: string email = 2; + */ + email = ''; + /** + * @generated from field: google.protobuf.Timestamp last_update_time = 3; + */ + lastUpdateTime; + /** + * @generated from field: string api_key = 4; + */ + apiKey = ''; + /** + * @generated from field: bool disable_codeium = 5; + */ + disableCodeium = false; + /** + * @generated from field: uint32 active_days = 6; + */ + activeDays = 0; + /** + * @generated from field: string role = 7; + */ + role = ''; + /** + * @generated from field: google.protobuf.Timestamp signup_time = 8; + */ + signupTime; + /** + * @generated from field: google.protobuf.Timestamp last_autocomplete_usage_time = 9; + */ + lastAutocompleteUsageTime; + /** + * @generated from field: google.protobuf.Timestamp last_chat_usage_time = 10; + */ + lastChatUsageTime; + /** + * @generated from field: google.protobuf.Timestamp last_command_usage_time = 11; + */ + lastCommandUsageTime; + /** + * @generated from field: int64 prompt_credits_used = 12; + */ + promptCreditsUsed = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.UserTableStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'email', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'last_update_time', kind: 'message', T: Timestamp }, + { + no: 4, + name: 'api_key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'disable_codeium', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'active_days', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 7, + name: 'role', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 8, name: 'signup_time', kind: 'message', T: Timestamp }, + { + no: 9, + name: 'last_autocomplete_usage_time', + kind: 'message', + T: Timestamp, + }, + { no: 10, name: 'last_chat_usage_time', kind: 'message', T: Timestamp }, + { no: 11, name: 'last_command_usage_time', kind: 'message', T: Timestamp }, + { + no: 12, + name: 'prompt_credits_used', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _UserTableStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserTableStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserTableStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserTableStats, a, b); + } +}; +var CascadeNUXState = class _CascadeNUXState extends Message { + /** + * @generated from field: exa.codeium_common_pb.CascadeNUXEvent event = 1; + */ + event = CascadeNUXEvent.CASCADE_NUX_EVENT_UNSPECIFIED; + /** + * @generated from field: google.protobuf.Timestamp timestamp = 2; + */ + timestamp; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CascadeNUXState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'event', + kind: 'enum', + T: proto3.getEnumType(CascadeNUXEvent), + }, + { no: 2, name: 'timestamp', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _CascadeNUXState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeNUXState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeNUXState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadeNUXState, a, b); + } +}; +var UserNUXState = class _UserNUXState extends Message { + /** + * @generated from field: exa.codeium_common_pb.UserNUXEvent event = 1; + */ + event = UserNUXEvent.USER_NUX_EVENT_UNSPECIFIED; + /** + * @generated from field: google.protobuf.Timestamp timestamp = 2; + */ + timestamp; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.UserNUXState'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'event', kind: 'enum', T: proto3.getEnumType(UserNUXEvent) }, + { no: 2, name: 'timestamp', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _UserNUXState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserNUXState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserNUXState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserNUXState, a, b); + } +}; +var ConversationBrainConfig = class _ConversationBrainConfig extends Message { + /** + * @generated from field: exa.codeium_common_pb.PlanMode plan_mode = 1; + */ + planMode = PlanMode.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ConversationBrainConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'plan_mode', kind: 'enum', T: proto3.getEnumType(PlanMode) }, + ]); + static fromBinary(bytes, options) { + return new _ConversationBrainConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConversationBrainConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConversationBrainConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConversationBrainConfig, a, b); + } +}; +var FeatureUsageData = class _FeatureUsageData extends Message { + /** + * @generated from field: bool has_used = 1; + */ + hasUsed = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.FeatureUsageData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'has_used', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _FeatureUsageData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FeatureUsageData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FeatureUsageData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FeatureUsageData, a, b); + } +}; +var CascadeNUXConfig = class _CascadeNUXConfig extends Message { + /** + * The UID for the nux. Users can only see a nux with a particular UID once. + * These should be assigned monotonically increasing IDs. + * + * @generated from field: uint32 uid = 1; + */ + uid = 0; + /** + * The location of the NUX. A nux will be shown at the location when the + * location mounts. + * + * @generated from field: exa.codeium_common_pb.CascadeNUXLocation location = 2; + */ + location = CascadeNUXLocation.CASCADE_NUX_LOCATION_UNSPECIFIED; + /** + * If provided, the NUX will only be shown when the trigger is met. + * + * @generated from field: exa.codeium_common_pb.CascadeNUXTrigger trigger = 3; + */ + trigger = CascadeNUXTrigger.CASCADE_NUX_TRIGGER_UNSPECIFIED; + /** + * Name to log the nux to analytics + * + * @generated from field: string analytics_event_name = 4; + */ + analyticsEventName = ''; + /** + * An optional URL to learn more about the NUX. Shown in a little "Learn More" + * button. Usually points to antigravity docs. + * + * @generated from field: string learn_more_url = 7; + */ + learnMoreUrl = ''; + /** + * Higher for NUXes that will be shown first. Usually should be zero. + * + * @generated from field: int32 priority = 8; + */ + priority = 0; + /** + * An optional icon for the NUX. + * + * @generated from field: exa.codeium_common_pb.CascadeNUXIcon icon = 10; + */ + icon = CascadeNUXIcon.CASCADE_NUX_ICON_UNSPECIFIED; + /** + * If true, the NUX will only be shown when Cascade is idle. + * + * @generated from field: bool requires_idle_cascade = 11; + */ + requiresIdleCascade = false; + /** + * Title of the NUX. + * + * @generated from field: string title = 12; + */ + title = ''; + /** + * Body of the NUX. + * + * @generated from field: optional string body = 13; + */ + body; + /** + * Image URL of the NUX. + * + * @generated from field: optional string image_url = 14; + */ + imageUrl; + /** + * Video URL of the NUX. + * + * @generated from field: optional string video_url = 15; + */ + videoUrl; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CascadeNUXConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'uid', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'location', + kind: 'enum', + T: proto3.getEnumType(CascadeNUXLocation), + }, + { + no: 3, + name: 'trigger', + kind: 'enum', + T: proto3.getEnumType(CascadeNUXTrigger), + }, + { + no: 4, + name: 'analytics_event_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'learn_more_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'priority', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 10, + name: 'icon', + kind: 'enum', + T: proto3.getEnumType(CascadeNUXIcon), + }, + { + no: 11, + name: 'requires_idle_cascade', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 12, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 13, name: 'body', kind: 'scalar', T: 9, opt: true }, + { no: 14, name: 'image_url', kind: 'scalar', T: 9, opt: true }, + { no: 15, name: 'video_url', kind: 'scalar', T: 9, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _CascadeNUXConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeNUXConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeNUXConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadeNUXConfig, a, b); + } +}; +var UserSettings = class _UserSettings extends Message { + /** + * Whether or not to start a new conversation or open to the most recent one + * when opening the chat panel in Codeium. + * Deprecated: Unused in jetski/antigravity. + * + * @generated from field: bool open_most_recent_chat_conversation = 1 [deprecated = true]; + * @deprecated + */ + openMostRecentChatConversation = false; + /** + * Last selected chat model ID. Used to make the model preference sticky + * between panel sessions. + * Deprecated: Unused in jetski/antigravity. + * + * @generated from field: exa.codeium_common_pb.Model last_selected_model = 2 [deprecated = true]; + * @deprecated + */ + lastSelectedModel = Model.UNSPECIFIED; + /** + * Not used in jetski/antigravity. + * + * @generated from field: exa.codeium_common_pb.ThemePreference theme_preference = 3 [deprecated = true]; + * @deprecated + */ + themePreference = ThemePreference.UNSPECIFIED; + /** + * Whether or not to remember last model choice (for chat & cascade) and + * persist it. Only allowed for some plans (not free) + * Deprecated: Unused + * + * @generated from field: exa.codeium_common_pb.RememberLastModelSelection remember_last_model_selection = 7 [deprecated = true]; + * @deprecated + */ + rememberLastModelSelection = RememberLastModelSelection.UNSPECIFIED; + /** + * The current mode of the autocomplete speed + * Deprecated: Use state sync for this. + * + * @generated from field: exa.codeium_common_pb.AutocompleteSpeed autocomplete_speed = 6 [deprecated = true]; + * @deprecated + */ + autocompleteSpeed = AutocompleteSpeed.UNSPECIFIED; + /** + * Name of the last model used for chat (needed for Enterprise external + * models) + * Deprecated: Unused in jetski/antigravity. + * + * @generated from field: string last_selected_model_name = 8 [deprecated = true]; + * @deprecated + */ + lastSelectedModelName = ''; + /** + * Cascade Settings that should be set only in the CascadePanel. + * They are set to optional so that the extension settings don't overwrite + * them. Last selected cascade model ID. Used to make the model preference + * sticky between panel sessions. + * Deprecated: Use State Sync + * + * @generated from field: optional exa.codeium_common_pb.Model last_selected_cascade_model = 9 [deprecated = true]; + * @deprecated + */ + lastSelectedCascadeModel; + /** + * Deprecated: Unused in jetski/antigravity. + * + * @generated from field: optional exa.codeium_common_pb.ModelOrAlias last_selected_cascade_model_or_alias = 30 [deprecated = true]; + * @deprecated + */ + lastSelectedCascadeModelOrAlias; + /** + * Deprecated: Unused in jetski/antigravity. + * + * @generated from field: optional exa.codeium_common_pb.ConversationalPlannerMode cascade_planner_mode = 13 [deprecated = true]; + * @deprecated + */ + cascadePlannerMode; + /** + * The last model that was used to override the user's last selected model. + * This is set via Unleash and is designed to force users in the experiment + * group to load up Cascade with a specific model that they may or may not + * have previously selected. Once applied, we cache the model override in this + * field so that we do not apply it again until the experiment changes, thus + * allowing the user to switch their model away from the model override at any + * time. This field is deprecated as we query the API server for the model + * override instead of unleash. + * + * @generated from field: optional exa.codeium_common_pb.Model last_model_override = 46 [deprecated = true]; + * @deprecated + */ + lastModelOverride; + /** + * The last model override version id that overrode the user's selection + * + * @generated from field: optional string last_model_default_override_version_id = 58; + */ + lastModelDefaultOverrideVersionId; + /** + * User-added allow list of commands that can be run by Cascade + * Cascade reads these via the CascadeConfig per-request, not from user + * settings. + * Deprecated: Use state sync for this. + * + * @generated from field: repeated string cascade_allowed_commands = 14 [deprecated = true]; + * @deprecated + */ + cascadeAllowedCommands = []; + /** + * User-added deny list of commands that can be run by Cascade + * Cascade reads these via the CascadeConfig per-request, not from user + * settings. + * Deprecated: Use state sync for this. + * + * @generated from field: repeated string cascade_denied_commands = 15 [deprecated = true]; + * @deprecated + */ + cascadeDeniedCommands = []; + /** + * Whether Cascade's web search is disabled. This is set to disabled so that + * it defaults to "on" when used in a headless environment without user + * settings. + * + * @generated from field: bool cascade_web_search_disabled = 18 [deprecated = true]; + * @deprecated + */ + cascadeWebSearchDisabled = false; + /** + * Denotes whether tab is on or off in Jetski + * Deprecated: Use state sync for this. + * + * @generated from field: exa.codeium_common_pb.TabEnabled tab_enabled = 67 [deprecated = true]; + * @deprecated + */ + tabEnabled = TabEnabled.UNSPECIFIED; + /** + * Disable the popup that appears when selecting code in antigravity + * Deprecated: Use unified state sync. + * + * @generated from field: bool disable_selection_popup = 21 [deprecated = true]; + * @deprecated + */ + disableSelectionPopup = false; + /** + * Disable inline hints for explain problem in antigravity + * Deprecated: Unused in jetskiy/antigravity. + * + * @generated from field: bool disable_explain_problem_inlay_hint = 22 [deprecated = true]; + * @deprecated + */ + disableExplainProblemInlayHint = false; + /** + * Disable inlay hints shortcuts in antigravity + * Deprecated: Unused in jetskiy/antigravity. + * + * @generated from field: bool disable_inlay_hint_shortcuts = 23 [deprecated = true]; + * @deprecated + */ + disableInlayHintShortcuts = false; + /** + * Disable automatically opening Cascade when reloading the editor + * + * @generated from field: bool disable_open_cascade_on_reload = 24; + */ + disableOpenCascadeOnReload = false; + /** + * Disable automatically opening files that were edited by Cascade + * + * @generated from field: bool disable_auto_open_edited_files = 25 [deprecated = true]; + * @deprecated + */ + disableAutoOpenEditedFiles = false; + /** + * Disable tab jump in antigravity + * + * @generated from field: bool disable_tab_to_jump = 26 [deprecated = true]; + * @deprecated + */ + disableTabToJump = false; + /** + * Cascade terminal commands auto execution mode + * Deprecated: Use state sync for this. + * + * @generated from field: exa.codeium_common_pb.CascadeCommandsAutoExecution cascade_auto_execution_policy = 27 [deprecated = true]; + * @deprecated + */ + cascadeAutoExecutionPolicy = CascadeCommandsAutoExecution.UNSPECIFIED; + /** + * The cascade id of the last selected conversation. + * + * @generated from field: optional string last_selected_cascade_id = 28 [deprecated = true]; + * @deprecated + */ + lastSelectedCascadeId; + /** + * Whether to send explain and fix problems to current conversation if there + * is a cascade id. + * + * @generated from field: bool explain_and_fix_in_current_conversation = 29; + */ + explainAndFixInCurrentConversation = false; + /** + * Whether Cascade can view or edit .gitignore files. Default to false. + * Deprecated: Use state sync for this. + * + * @generated from field: bool allow_cascade_access_gitignore_files = 31 [deprecated = true]; + * @deprecated + */ + allowCascadeAccessGitignoreFiles = false; + /** + * Whether Agent can view or edit non-workspace files. Default to false. + * Deprecated: Use state sync for this. + * + * @generated from field: bool allow_agent_access_non_workspace_files = 79 [deprecated = true]; + * @deprecated + */ + allowAgentAccessNonWorkspaceFiles = false; + /** + * Whether to disable auto fix lint functionality for Cascade. + * Deprecated: Use state sync for this. + * + * @generated from field: bool disable_cascade_auto_fix_lints = 32 [deprecated = true]; + * @deprecated + */ + disableCascadeAutoFixLints = false; + /** + * @generated from field: exa.codeium_common_pb.DetectAndUseProxy detect_and_use_proxy = 34; + */ + detectAndUseProxy = DetectAndUseProxy.UNSPECIFIED; + /** + * Deprecated: Use state sync for this. + * + * @generated from field: bool disable_tab_to_import = 35 [deprecated = true]; + * @deprecated + */ + disableTabToImport = false; + /** + * Deprecated: Use state sync for this. + * + * @generated from field: bool use_clipboard_for_completions = 36 [deprecated = true]; + * @deprecated + */ + useClipboardForCompletions = false; + /** + * Deprecated: Use state sync for this. + * + * @generated from field: bool disable_highlight_after_accept = 37 [deprecated = true]; + * @deprecated + */ + disableHighlightAfterAccept = false; + /** + * If true, Cascade does not create autogenerated memories unless explicitly + * asked + * Deprecated: Use state sync for this. + * + * @generated from field: bool disable_auto_generate_memories = 39 [deprecated = true]; + * @deprecated + */ + disableAutoGenerateMemories = false; + /** + * If true, the IDE plays sounds on certain events, e.g. when Cascade finishes + * generating a response + * + * @generated from field: bool enable_sounds_for_special_events = 40; + */ + enableSoundsForSpecialEvents = false; + /** + * If true, the IDE plays sounds (in sequence, forming a melody) when + * accepting Antigravity Tab suggestions. This is a temporary feature for + * April Fool's. + * Deprecated: Use state sync for this. + * + * @generated from field: bool enable_tab_sounds = 41 [deprecated = true]; + * @deprecated + */ + enableTabSounds = false; + /** + * Deprecated flag to determine if Cascade can run in the background. + * disable_cascade_in_background is the new flag to control this behavior + * since we want this to be enabled by default now. + * + * @generated from field: bool allow_cascade_in_background = 42 [deprecated = true]; + * @deprecated + */ + allowCascadeInBackground = false; + /** + * Deprecated: Use state sync for this. + * + * @generated from field: exa.codeium_common_pb.TabToJump tab_to_jump = 43 [deprecated = true]; + * @deprecated + */ + tabToJump = TabToJump.UNSPECIFIED; + /** + * @generated from field: exa.codeium_common_pb.CascadeWebSearchTool cascade_web_search = 44; + */ + cascadeWebSearch = CascadeWebSearchTool.UNSPECIFIED; + /** + * Whether to enable terminal completions + * Deprecated: Use state sync for this. + * + * @generated from field: bool enable_terminal_completion = 45 [deprecated = true]; + * @deprecated + */ + enableTerminalCompletion = false; + /** + * Whether Antigravity Tab completions are snoozed + * Deprecated: Use state sync for this. + * + * @generated from field: bool is_snoozed = 55 [deprecated = true]; + * @deprecated + */ + isSnoozed = false; + /** + * Whether to disable Cascade from running in the background + * Deprecated: Unused in jetski/antigravity. + * + * @generated from field: bool disable_cascade_in_background = 48 [deprecated = true]; + * @deprecated + */ + disableCascadeInBackground = false; + /** + * Custom workspaces for Enterprise Users. Tool calls will always pass for + * these workspaces. Tool calls currently fail outside tracked worskspace if + * GetEnforceWorkspaceValidation is set. + * + * @generated from field: repeated string custom_workspace = 50; + */ + customWorkspace = []; + /** + * The user's global plan mode preference. + * Deprecated: Unused. + * + * @generated from field: exa.codeium_common_pb.PlanMode global_plan_mode_preference = 54 [deprecated = true]; + * @deprecated + */ + globalPlanModePreference = PlanMode.UNSPECIFIED; + /** + * Cached model configurations for Cascade + * Deprecated: Unused in jetski/antigravity. + * + * @generated from field: repeated exa.codeium_common_pb.ClientModelConfig cached_cascade_model_configs = 52 [deprecated = true]; + * @deprecated + */ + cachedCascadeModelConfigs = []; + /** + * Cached model sorts for Cascade + * Deprecated: Unused in jetski/antigravity. + * + * @generated from field: repeated exa.codeium_common_pb.ClientModelSort cached_cascade_model_sorts = 53 [deprecated = true]; + * @deprecated + */ + cachedCascadeModelSorts = []; + /** + * Whether to enable Cascade extension code execution + * Deprecated: Run extension code is unused. + * + * @generated from field: exa.codeium_common_pb.CascadeRunExtensionCode cascade_run_extension_code = 56 [deprecated = true]; + * @deprecated + */ + cascadeRunExtensionCode = CascadeRunExtensionCode.UNSPECIFIED; + /** + * Whether to enable Cascade extension code auto-run + * Deprecated: Run extension code is unused. + * + * @generated from field: exa.codeium_common_pb.CascadeRunExtensionCodeAutoRun cascade_run_extension_code_auto_run = 57 [deprecated = true]; + * @deprecated + */ + cascadeRunExtensionCodeAutoRun = CascadeRunExtensionCodeAutoRun.UNSPECIFIED; + /** + * Deprecated: Unused in jetski/antigravity. + * + * @generated from field: exa.codeium_common_pb.CascadeInputAutocomplete cascade_input_autocomplete = 65 [deprecated = true]; + * @deprecated + */ + cascadeInputAutocomplete = CascadeInputAutocomplete.UNSPECIFIED; + /** + * Global auto-continue-on-max-invocator-generations setting + * + * @generated from field: exa.codeium_common_pb.AutoContinueOnMaxGeneratorInvocations auto_continue_on_max_generator_invocations = 59; + */ + autoContinueOnMaxGeneratorInvocations = + AutoContinueOnMaxGeneratorInvocations.UNSPECIFIED; + /** + * List of recently used cascade models (LRU order, max 3 items) + * Deprecated: Essentially unused + * + * @generated from field: repeated string recently_used_cascade_models = 61 [deprecated = true]; + * @deprecated + */ + recentlyUsedCascadeModels = []; + /** + * Whether to enable annotations + * Deprecated: Unused in jetski/antigravity. + * + * @generated from field: exa.codeium_common_pb.AnnotationsConfig annotations_config = 63 [deprecated = true]; + * @deprecated + */ + annotationsConfig = AnnotationsConfig.UNSPECIFIED; + /** + * If populated, automatically sets the working directories relative to the + * first workspace. + * + * @generated from field: repeated string relative_working_dir_paths = 66; + */ + relativeWorkingDirPaths = []; + /** + * Custom models specified by the user, currently used to support models + * specified via Model URL's. + * + * @generated from field: map custom_models = 68; + */ + customModels = {}; + /** + * Disable code snippet telemtry. + * This setting gets synced with the users table via the API server and + * isn't only applied to the machine level. + * + * @generated from field: bool disable_code_snippet_telemetry = 69; + */ + disableCodeSnippetTelemetry = false; + /** + * Whether planning is enabled or disabled. This is separate from + * (but an evolution of) the "plan mode" functionality that the agent had in + * the past. + * Deprecated: Use state sync for this. + * + * @generated from field: exa.codeium_common_pb.PlanningMode planning_mode = 70 [deprecated = true]; + * @deprecated + */ + planningMode = PlanningMode.UNSPECIFIED; + /** + * Controls whether browser tools are enabled for the Agent + * Deprecated: Use state sync for this. + * + * @generated from field: exa.codeium_common_pb.AgentBrowserTools agent_browser_tools = 71 [deprecated = true]; + * @deprecated + */ + agentBrowserTools = AgentBrowserTools.UNSPECIFIED; + /** + * Controls when notify_user requests the user to review generated artifacts. + * Deprecated: Use state sync for this. + * + * @generated from field: exa.codeium_common_pb.ArtifactReviewMode artifact_review_mode = 72 [deprecated = true]; + * @deprecated + */ + artifactReviewMode = ArtifactReviewMode.UNSPECIFIED; + /** + * Whether Tab can view or edit gitignore files. Defaults to false. + * Deprecated: Use state sync for this. + * + * @generated from field: bool allow_tab_access_gitignore_files = 75 [deprecated = true]; + * @deprecated + */ + allowTabAccessGitignoreFiles = false; + /** + * Path to the Chrome/Chromium executable. If not specified, the system will + * attempt to detect the Chrome installation automatically. + * Deprecated: Use state sync for this. + * + * @generated from field: string browser_chrome_path = 76 [deprecated = true]; + * @deprecated + */ + browserChromePath = ''; + /** + * Custom path for the browser user profile directory. If not specified, the + * default profile path will be used. + * Deprecated: Use state sync for this. + * + * @generated from field: string browser_user_profile_path = 77 [deprecated = true]; + * @deprecated + */ + browserUserProfilePath = ''; + /** + * Port number for Chrome DevTools Protocol remote debugging. Default is 9222. + * Changed to avoid port conflicts. + * Deprecated: Use state sync for this. + * + * @generated from field: int32 browser_cdp_port = 78 [deprecated = true]; + * @deprecated + */ + browserCdpPort = 0; + /** + * Whether we are in demo mode. This will modify parts of the UI to make + * demoing cleaner and more consistent. This does not control the underlying + * ~/.gemini data directory. + * Deprecated: Use state sync for this. + * + * @generated from field: bool demo_mode_enabled = 80 [deprecated = true]; + * @deprecated + */ + demoModeEnabled = false; + /** + * Policy for how the browser subagent handles Javascript execution + * Deprecated: Use state sync for this. + * + * @generated from field: exa.codeium_common_pb.BrowserJsExecutionPolicy browser_js_execution_policy = 81 [deprecated = true]; + * @deprecated + */ + browserJsExecutionPolicy = BrowserJsExecutionPolicy.UNSPECIFIED; + /** + * Whether the IDE is in secure mode, which enforces certain security + * restrictions (eg. terminal, browser execution, gitignore access) + * Deprecated: Use state sync for this. + * + * @generated from field: bool secure_mode_enabled = 82 [deprecated = true]; + * @deprecated + */ + secureModeEnabled = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.UserSettings'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'open_most_recent_chat_conversation', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'last_selected_model', + kind: 'enum', + T: proto3.getEnumType(Model), + }, + { + no: 3, + name: 'theme_preference', + kind: 'enum', + T: proto3.getEnumType(ThemePreference), + }, + { + no: 7, + name: 'remember_last_model_selection', + kind: 'enum', + T: proto3.getEnumType(RememberLastModelSelection), + }, + { + no: 6, + name: 'autocomplete_speed', + kind: 'enum', + T: proto3.getEnumType(AutocompleteSpeed), + }, + { + no: 8, + name: 'last_selected_model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'last_selected_cascade_model', + kind: 'enum', + T: proto3.getEnumType(Model), + opt: true, + }, + { + no: 30, + name: 'last_selected_cascade_model_or_alias', + kind: 'message', + T: ModelOrAlias, + opt: true, + }, + { + no: 13, + name: 'cascade_planner_mode', + kind: 'enum', + T: proto3.getEnumType(ConversationalPlannerMode), + opt: true, + }, + { + no: 46, + name: 'last_model_override', + kind: 'enum', + T: proto3.getEnumType(Model), + opt: true, + }, + { + no: 58, + name: 'last_model_default_override_version_id', + kind: 'scalar', + T: 9, + opt: true, + }, + { + no: 14, + name: 'cascade_allowed_commands', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 15, + name: 'cascade_denied_commands', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 18, + name: 'cascade_web_search_disabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 67, + name: 'tab_enabled', + kind: 'enum', + T: proto3.getEnumType(TabEnabled), + }, + { + no: 21, + name: 'disable_selection_popup', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 22, + name: 'disable_explain_problem_inlay_hint', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 23, + name: 'disable_inlay_hint_shortcuts', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 24, + name: 'disable_open_cascade_on_reload', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 25, + name: 'disable_auto_open_edited_files', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 26, + name: 'disable_tab_to_jump', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 27, + name: 'cascade_auto_execution_policy', + kind: 'enum', + T: proto3.getEnumType(CascadeCommandsAutoExecution), + }, + { + no: 28, + name: 'last_selected_cascade_id', + kind: 'scalar', + T: 9, + opt: true, + }, + { + no: 29, + name: 'explain_and_fix_in_current_conversation', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 31, + name: 'allow_cascade_access_gitignore_files', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 79, + name: 'allow_agent_access_non_workspace_files', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 32, + name: 'disable_cascade_auto_fix_lints', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 34, + name: 'detect_and_use_proxy', + kind: 'enum', + T: proto3.getEnumType(DetectAndUseProxy), + }, + { + no: 35, + name: 'disable_tab_to_import', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 36, + name: 'use_clipboard_for_completions', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 37, + name: 'disable_highlight_after_accept', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 39, + name: 'disable_auto_generate_memories', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 40, + name: 'enable_sounds_for_special_events', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 41, + name: 'enable_tab_sounds', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 42, + name: 'allow_cascade_in_background', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 43, + name: 'tab_to_jump', + kind: 'enum', + T: proto3.getEnumType(TabToJump), + }, + { + no: 44, + name: 'cascade_web_search', + kind: 'enum', + T: proto3.getEnumType(CascadeWebSearchTool), + }, + { + no: 45, + name: 'enable_terminal_completion', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 55, + name: 'is_snoozed', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 48, + name: 'disable_cascade_in_background', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 50, name: 'custom_workspace', kind: 'scalar', T: 9, repeated: true }, + { + no: 54, + name: 'global_plan_mode_preference', + kind: 'enum', + T: proto3.getEnumType(PlanMode), + }, + { + no: 52, + name: 'cached_cascade_model_configs', + kind: 'message', + T: ClientModelConfig, + repeated: true, + }, + { + no: 53, + name: 'cached_cascade_model_sorts', + kind: 'message', + T: ClientModelSort, + repeated: true, + }, + { + no: 56, + name: 'cascade_run_extension_code', + kind: 'enum', + T: proto3.getEnumType(CascadeRunExtensionCode), + }, + { + no: 57, + name: 'cascade_run_extension_code_auto_run', + kind: 'enum', + T: proto3.getEnumType(CascadeRunExtensionCodeAutoRun), + }, + { + no: 65, + name: 'cascade_input_autocomplete', + kind: 'enum', + T: proto3.getEnumType(CascadeInputAutocomplete), + }, + { + no: 59, + name: 'auto_continue_on_max_generator_invocations', + kind: 'enum', + T: proto3.getEnumType(AutoContinueOnMaxGeneratorInvocations), + }, + { + no: 61, + name: 'recently_used_cascade_models', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 63, + name: 'annotations_config', + kind: 'enum', + T: proto3.getEnumType(AnnotationsConfig), + }, + { + no: 66, + name: 'relative_working_dir_paths', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 68, + name: 'custom_models', + kind: 'map', + K: 9, + V: { kind: 'message', T: ModelInfo }, + }, + { + no: 69, + name: 'disable_code_snippet_telemetry', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 70, + name: 'planning_mode', + kind: 'enum', + T: proto3.getEnumType(PlanningMode), + }, + { + no: 71, + name: 'agent_browser_tools', + kind: 'enum', + T: proto3.getEnumType(AgentBrowserTools), + }, + { + no: 72, + name: 'artifact_review_mode', + kind: 'enum', + T: proto3.getEnumType(ArtifactReviewMode), + }, + { + no: 75, + name: 'allow_tab_access_gitignore_files', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 76, + name: 'browser_chrome_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 77, + name: 'browser_user_profile_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 78, + name: 'browser_cdp_port', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 80, + name: 'demo_mode_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 81, + name: 'browser_js_execution_policy', + kind: 'enum', + T: proto3.getEnumType(BrowserJsExecutionPolicy), + }, + { + no: 82, + name: 'secure_mode_enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _UserSettings().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserSettings().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserSettings().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserSettings, a, b); + } +}; +var UserAccountSettings = class _UserAccountSettings extends Message { + /** + * @generated from field: bool disable_code_snippet_telemetry = 1; + */ + disableCodeSnippetTelemetry = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.UserAccountSettings'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'disable_code_snippet_telemetry', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _UserAccountSettings().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserAccountSettings().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserAccountSettings().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserAccountSettings, a, b); + } +}; +var ModelFeatures = class _ModelFeatures extends Message { + /** + * Context token FT models. When true, prompts will use special tokens to wrap + * code context items instead of adding them as commented code blocks. + * + * @generated from field: bool supports_context_tokens = 2; + */ + supportsContextTokens = false; + /** + * Chat-based codeium command IFT models. When true, command prompts will use + * llama-instruct [INST] and [/INST] tags. + * + * @generated from field: bool requires_instruct_tags = 3; + */ + requiresInstructTags = false; + /** + * Training examples use FIM at a per-example level. When true, prompts will + * wrap the context section of the prompt in a FIM block. Regardless of + * whether or not this is set, the context section will always occur before + * the current document FIM block in the prompt. + * + * @generated from field: bool requires_fim_context = 4; + */ + requiresFimContext = false; + /** + * Context snippet prefix. When true, prompts will include "Context from" in + * the prefix before context item snippets. Regardless of whether or not this + * is set, the context type and node path will be included in the context item + * snippet prefix. + * + * @generated from field: bool requires_context_snippet_prefix = 5; + */ + requiresContextSnippetPrefix = false; + /** + * Context relevance tags instead of special tokens for the context check + * task. When true, prompts will use no special tokens for the context check + * task. + * + * @generated from field: bool requires_context_relevance_tags = 6; + */ + requiresContextRelevanceTags = false; + /** + * Whether to inject LLama3 header tokens when formatting chat prompt. + * https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3 + * + * @generated from field: bool requires_llama3_tokens = 7; + */ + requiresLlama3Tokens = false; + /** + * Whether model can support arbitrary prompt text. Used for configuring + * prompt based experiments. + * + * @generated from field: bool zero_shot_capable = 8; + */ + zeroShotCapable = false; + /** + * Whether the model uses the autocomplete as command formatting + * (Formatting an autocomplete request as a generalized "command generate" + * prompt that supports inline prefix/suffix. Generally, only used by FIM + * capable chat models.) + * + * @generated from field: bool requires_autocomplete_as_command = 9; + */ + requiresAutocompleteAsCommand = false; + /** + * Whether the model supports putting <|cursor|> in the supercomplete + * selection to signify where the cursor is. NOTE(anthonywang): Making this + * "supports" for now since it is worse for a cursor unaware model to receive + * a cursor aware prompt (because it will start leaking the cursor) than for a + * cursor aware model to receive a cursor unaware prompt, although the cursor + * aware model will likely have unknown behavior if given the cursor unaware + * prompt. This field is used for both autocomplete and supercomplete prompt + * construction right now. + * + * @generated from field: bool supports_cursor_aware_supercomplete = 10; + */ + supportsCursorAwareSupercomplete = false; + /** + * Whether the model supports vision + * + * @generated from field: bool supports_images = 11; + */ + supportsImages = false; + /** + * @generated from field: bool supports_pdf = 22; + */ + supportsPdf = false; + /** + * @generated from field: bool supports_video = 23; + */ + supportsVideo = false; + /** + * Map of MIME types to whether the model supports them. + * If this map is populated, it takes precedence over the individual boolean + * fields (supports_images, supports_pdf, supports_video). + * + * @generated from field: map supported_mime_types = 28; + */ + supportedMimeTypes = {}; + /** + * Whether the model supports tool calls + * + * @generated from field: bool supports_tool_calls = 12; + */ + supportsToolCalls = false; + /** + * Does not support tool choice. This is irrelevant unless supports_tool_calls + * is true. + * + * @generated from field: bool does_not_support_tool_choice = 27; + */ + doesNotSupportToolChoice = false; + /** + * Whether the model supports cache-aware prompts, where different kinds of + * context can be interleaved. + * TODO(devin): Making this "supports" for now, since even though the format + * is completely different from existing models, the old prompt format could + * hypothetically be expressed as a cumulative format, and maybe we'll train + * models in the new format but without interleaving. In practice, this routes + * prompt construction to a completely different code path. + * + * @generated from field: bool supports_cumulative_context = 13; + */ + supportsCumulativeContext = false; + /** + * Whether the model supports printing line range in tab jump instructions + * + * @generated from field: bool tab_jump_print_line_range = 14; + */ + tabJumpPrintLineRange = false; + /** + * Whether the model supports thinking. + * + * @generated from field: bool supports_thinking = 15; + */ + supportsThinking = false; + /** + * Deprecated: No need for this field anymore, just always circulate the + * thinking text and signature. + * + * @generated from field: bool supports_raw_thinking = 21 [deprecated = true]; + * @deprecated + */ + supportsRawThinking = false; + /** + * Whether the model can use the estimate tokenizer (estimates number of + * tokens after tokenization) instead of its real tokenizer in the LS and api + * server. Note that these estimates are NOT expected to be conservative. This + * requires the model/inference server to be robust to both over and under + * estimates of prompt length in tokens. WE TREAT THIS AS ALWAYS TRUE. + * TODO(bshimanuki): Remove this. + * + * @generated from field: bool supports_estimate_token_counter = 17; + */ + supportsEstimateTokenCounter = false; + /** + * Whether the model supports adding cursor markers in the find replace target + * + * @generated from field: bool add_cursor_to_find_replace_target = 18; + */ + addCursorToFindReplaceTarget = false; + /** + * Whether the model supports jumping to the whole document instead of just in + * the selection. This is used for controlling what we match against. NOTE: + * Having this model feature REQUIRES tab_jump_print_line_range to be true. + * + * @generated from field: bool supports_tab_jump_use_whole_document = 19; + */ + supportsTabJumpUseWholeDocument = false; + /** + * Whether the model supports its model info being overridden. This is used + * for supporting BYOM and allowing eval users to vary model info from within + * the rollout worker config. + * + * @generated from field: bool supports_model_info_override = 24; + */ + supportsModelInfoOverride = false; + /** + * For tab prompting, whether lead in generation of the completion (i.e. the + * beginning of the replace_file_content tool response) is required. + * + * @generated from field: bool requires_lead_in_generation = 25; + */ + requiresLeadInGeneration = false; + /** + * Whether the model requires no XML tool examples. + * TODO(aywang, sumithn, xuanhaoc, slohier, changsean, nicholasjiang): + * This is horrible. Please remove during the model config refactor. + * + * @generated from field: bool requires_no_xml_tool_examples = 26; + */ + requiresNoXmlToolExamples = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ModelFeatures'; + static fields = proto3.util.newFieldList(() => [ + { + no: 2, + name: 'supports_context_tokens', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'requires_instruct_tags', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'requires_fim_context', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'requires_context_snippet_prefix', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'requires_context_relevance_tags', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'requires_llama3_tokens', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 8, + name: 'zero_shot_capable', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 9, + name: 'requires_autocomplete_as_command', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 10, + name: 'supports_cursor_aware_supercomplete', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 11, + name: 'supports_images', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 22, + name: 'supports_pdf', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 23, + name: 'supports_video', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 28, + name: 'supported_mime_types', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + }, + { + no: 12, + name: 'supports_tool_calls', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 27, + name: 'does_not_support_tool_choice', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 13, + name: 'supports_cumulative_context', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 14, + name: 'tab_jump_print_line_range', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 15, + name: 'supports_thinking', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 21, + name: 'supports_raw_thinking', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 17, + name: 'supports_estimate_token_counter', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 18, + name: 'add_cursor_to_find_replace_target', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 19, + name: 'supports_tab_jump_use_whole_document', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 24, + name: 'supports_model_info_override', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 25, + name: 'requires_lead_in_generation', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 26, + name: 'requires_no_xml_tool_examples', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ModelFeatures().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelFeatures().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ModelFeatures().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ModelFeatures, a, b); + } +}; +var ExternalModel = class _ExternalModel extends Message { + /** + * @generated from field: bool is_internal = 1; + */ + isInternal = false; + /** + * @generated from field: exa.codeium_common_pb.Model model_id = 2; + */ + modelId = Model.UNSPECIFIED; + /** + * @generated from field: string model_name = 3; + */ + modelName = ''; + /** + * @generated from field: string base_url = 4; + */ + baseUrl = ''; + /** + * @generated from field: string api_key = 5; + */ + apiKey = ''; + /** + * @generated from field: string access_key = 6; + */ + accessKey = ''; + /** + * @generated from field: string secret_access_key = 7; + */ + secretAccessKey = ''; + /** + * @generated from field: string region = 8; + */ + region = ''; + /** + * @generated from field: string project_id = 9; + */ + projectId = ''; + /** + * @generated from field: uint32 id = 10; + */ + id = 0; + /** + * @generated from field: int32 max_completion_tokens = 11; + */ + maxCompletionTokens = 0; + /** + * @generated from field: int32 max_input_tokens = 12; + */ + maxInputTokens = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ExternalModel'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'is_internal', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 2, name: 'model_id', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 3, + name: 'model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'base_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'api_key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'access_key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'secret_access_key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'region', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'project_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'id', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 11, + name: 'max_completion_tokens', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 12, + name: 'max_input_tokens', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ExternalModel().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ExternalModel().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ExternalModel().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ExternalModel, a, b); + } +}; +var ModelInfo = class _ModelInfo extends Message { + /** + * @generated from field: exa.codeium_common_pb.Model model_id = 1; + */ + modelId = Model.UNSPECIFIED; + /** + * This is used to indicate whether the model is finetuned with an internal + * prompt format. + * TODO(nick, pavan): This should be deprecated since it we should now be + * using api_provider to indicate model is served internally and model + * features for prompt-related features. + * + * @generated from field: bool is_internal = 2; + */ + isInternal = false; + /** + * @generated from field: exa.codeium_common_pb.ModelType model_type = 3; + */ + modelType = ModelType.UNSPECIFIED; + /** + * Total max tokens for the model including generation and prompt. + * + * @generated from field: int32 max_tokens = 4; + */ + maxTokens = 0; + /** + * String representing tokenizer type of model. + * + * @generated from field: string tokenizer_type = 5; + */ + tokenizerType = ''; + /** + * @generated from field: exa.codeium_common_pb.ModelFeatures model_features = 6; + */ + modelFeatures; + /** + * @generated from field: exa.codeium_common_pb.APIProvider api_provider = 7; + */ + apiProvider = APIProvider.API_PROVIDER_UNSPECIFIED; + /** + * Model name for api calls. + * + * @generated from field: string model_name = 8; + */ + modelName = ''; + /** + * @generated from field: bool supports_context = 9; + */ + supportsContext = false; + /** + * Embedding dimension for the model. + * + * @generated from field: int32 embed_dim = 10; + */ + embedDim = 0; + /** + * @generated from field: string base_url = 11; + */ + baseUrl = ''; + /** + * Set within api server for easier use of external models + * + * @generated from field: string chat_model_name = 12; + */ + chatModelName = ''; + /** + * Max output tokens for the model. This is only ever set for external API + * providers since MaxOutputTokens is set on the inference server for any + * internal models. + * + * @generated from field: int32 max_output_tokens = 13; + */ + maxOutputTokens = 0; + /** + * Default type of chat prompt template to use for this model. + * + * @generated from field: exa.codeium_common_pb.PromptTemplaterType prompt_templater_type = 14; + */ + promptTemplaterType = PromptTemplaterType.UNSPECIFIED; + /** + * Default type of tool formatter to use for this model. + * + * @generated from field: exa.codeium_common_pb.ToolFormatterType tool_formatter_type = 15; + */ + toolFormatterType = ToolFormatterType.UNSPECIFIED; + /** + * Thinking budget (max tokens) for models that support thinking. + * If set to -1, the model does dynamic thinking. + * https://ai.google.dev/gemini-api/docs/thinking#set-budget + * + * @generated from field: int32 thinking_budget = 16; + */ + thinkingBudget = 0; + /** + * Min thinking budget required by the model. + * + * @generated from field: int32 min_thinking_budget = 17; + */ + minThinkingBudget = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ModelInfo'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'model_id', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 2, + name: 'is_internal', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'model_type', + kind: 'enum', + T: proto3.getEnumType(ModelType), + }, + { + no: 4, + name: 'max_tokens', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'tokenizer_type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 6, name: 'model_features', kind: 'message', T: ModelFeatures }, + { + no: 7, + name: 'api_provider', + kind: 'enum', + T: proto3.getEnumType(APIProvider), + }, + { + no: 8, + name: 'model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'supports_context', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 10, + name: 'embed_dim', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 11, + name: 'base_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'chat_model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 13, + name: 'max_output_tokens', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 14, + name: 'prompt_templater_type', + kind: 'enum', + T: proto3.getEnumType(PromptTemplaterType), + }, + { + no: 15, + name: 'tool_formatter_type', + kind: 'enum', + T: proto3.getEnumType(ToolFormatterType), + }, + { + no: 16, + name: 'thinking_budget', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 17, + name: 'min_thinking_budget', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ModelInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ModelInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ModelInfo, a, b); + } +}; +var ApiProviderRoutingConfig = class _ApiProviderRoutingConfig extends Message { + /** + * @generated from field: map model_map = 1; + */ + modelMap = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ApiProviderRoutingConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'model_map', + kind: 'map', + K: 9, + V: { kind: 'message', T: ApiProviderConfigMap }, + }, + ]); + static fromBinary(bytes, options) { + return new _ApiProviderRoutingConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ApiProviderRoutingConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ApiProviderRoutingConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ApiProviderRoutingConfig, a, b); + } +}; +var ApiProviderConfigMap = class _ApiProviderConfigMap extends Message { + /** + * @generated from field: map provider_map = 1; + */ + providerMap = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ApiProviderConfigMap'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'provider_map', + kind: 'map', + K: 9, + V: { kind: 'message', T: ApiProviderConfig }, + }, + ]); + static fromBinary(bytes, options) { + return new _ApiProviderConfigMap().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ApiProviderConfigMap().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ApiProviderConfigMap().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ApiProviderConfigMap, a, b); + } +}; +var ApiProviderConfig = class _ApiProviderConfig extends Message { + /** + * @generated from field: uint32 weight = 1; + */ + weight = 0; + /** + * @generated from field: uint32 cache_ttl_minutes = 2; + */ + cacheTtlMinutes = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ApiProviderConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'weight', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'cache_ttl_minutes', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ApiProviderConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ApiProviderConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ApiProviderConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ApiProviderConfig, a, b); + } +}; +var ModelConfig = class _ModelConfig extends Message { + /** + * @generated from field: exa.codeium_common_pb.ModelInfo generation_model = 1; + */ + generationModel; + /** + * Model info used for Context Checking/Reasoning. This is only populated for + * chat models. + * + * @generated from field: exa.codeium_common_pb.ModelInfo context_check_model = 2; + */ + contextCheckModel; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ModelConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'generation_model', kind: 'message', T: ModelInfo }, + { no: 2, name: 'context_check_model', kind: 'message', T: ModelInfo }, + ]); + static fromBinary(bytes, options) { + return new _ModelConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ModelConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ModelConfig, a, b); + } +}; +var ModelStatusInfo = class _ModelStatusInfo extends Message { + /** + * @generated from field: exa.codeium_common_pb.Model model = 1; + */ + model = Model.UNSPECIFIED; + /** + * @generated from field: string message = 2; + */ + message = ''; + /** + * @generated from field: exa.codeium_common_pb.ModelStatus status = 3; + */ + status = ModelStatus.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ModelStatusInfo'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'model', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 2, + name: 'message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'status', kind: 'enum', T: proto3.getEnumType(ModelStatus) }, + ]); + static fromBinary(bytes, options) { + return new _ModelStatusInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelStatusInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ModelStatusInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ModelStatusInfo, a, b); + } +}; +var CompletionExample = class _CompletionExample extends Message { + /** + * @generated from field: string uid = 1; + */ + uid = ''; + /** + * @generated from field: string completion_id = 2; + */ + completionId = ''; + /** + * @generated from field: string file_path = 3; + */ + filePath = ''; + /** + * @generated from field: string short_prefix = 4; + */ + shortPrefix = ''; + /** + * @generated from field: string completion_text = 5; + */ + completionText = ''; + /** + * @generated from field: string short_suffix = 6; + */ + shortSuffix = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionExample'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'uid', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'completion_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'file_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'short_prefix', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'completion_text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'short_suffix', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionExample().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionExample().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionExample().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionExample, a, b); + } +}; +var CompletionExampleWithMetadata = class _CompletionExampleWithMetadata extends Message { + /** + * @generated from field: exa.codeium_common_pb.CompletionExample example = 1; + */ + example; + /** + * Display name from users.name. + * + * @generated from field: string name = 2; + */ + name = ''; + /** + * @generated from field: google.protobuf.Timestamp time = 4; + */ + time; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionExampleWithMetadata'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'example', kind: 'message', T: CompletionExample }, + { + no: 2, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'time', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _CompletionExampleWithMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionExampleWithMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionExampleWithMetadata().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CompletionExampleWithMetadata, a, b); + } +}; +var CciWithSubrange = class _CciWithSubrange extends Message { + /** + * @generated from field: exa.codeium_common_pb.CodeContextItem cci = 1; + */ + cci; + /** + * @generated from field: exa.codeium_common_pb.ContextSubrange subrange = 2; + */ + subrange; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CciWithSubrange'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'cci', kind: 'message', T: CodeContextItem }, + { no: 2, name: 'subrange', kind: 'message', T: ContextSubrange }, + ]); + static fromBinary(bytes, options) { + return new _CciWithSubrange().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CciWithSubrange().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CciWithSubrange().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CciWithSubrange, a, b); + } +}; +var ContextSubrange = class _ContextSubrange extends Message { + /** + * @generated from field: exa.codeium_common_pb.ContextSnippetType snippet_type = 1; + */ + snippetType = ContextSnippetType.UNSPECIFIED; + /** + * Zero-indexed byte offset in the snippet string corresponding to + * ContextSnippetType. Inclusive. A value of 0 for start and end-offset + * indicates that the subrange covers the whole snippet. + * + * @generated from field: int64 start_offset = 2; + */ + startOffset = protoInt64.zero; + /** + * @generated from field: int64 end_offset = 3; + */ + endOffset = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ContextSubrange'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'snippet_type', + kind: 'enum', + T: proto3.getEnumType(ContextSnippetType), + }, + { + no: 2, + name: 'start_offset', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 3, + name: 'end_offset', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ContextSubrange().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextSubrange().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextSubrange().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ContextSubrange, a, b); + } +}; +var PathScopeItem = class _PathScopeItem extends Message { + /** + * @generated from field: string absolute_path_migrate_me_to_uri = 1 [deprecated = true]; + * @deprecated + */ + absolutePathMigrateMeToUri = ''; + /** + * @generated from field: string absolute_uri = 5; + */ + absoluteUri = ''; + /** + * Map from workspace path to relative path. + * + * @generated from field: map workspace_relative_paths_migrate_me_to_workspace_uris = 2 [deprecated = true]; + * @deprecated + */ + workspaceRelativePathsMigrateMeToWorkspaceUris = {}; + /** + * @generated from field: map workspace_uris_to_relative_paths = 6; + */ + workspaceUrisToRelativePaths = {}; + /** + * Data within this scope. + * + * @generated from field: uint32 num_files = 3; + */ + numFiles = 0; + /** + * @generated from field: uint64 num_bytes = 4; + */ + numBytes = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PathScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_path_migrate_me_to_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'workspace_relative_paths_migrate_me_to_workspace_uris', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { + no: 6, + name: 'workspace_uris_to_relative_paths', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { + no: 3, + name: 'num_files', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'num_bytes', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _PathScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PathScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PathScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PathScopeItem, a, b); + } +}; +var FileLineRange = class _FileLineRange extends Message { + /** + * @generated from field: string absolute_uri = 1; + */ + absoluteUri = ''; + /** + * 0-indexed + * + * @generated from field: uint32 start_line = 2; + */ + startLine = 0; + /** + * inclusive, ignored if 0 or equal to start_line + * + * @generated from field: uint32 end_line = 3; + */ + endLine = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.FileLineRange'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'start_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'end_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _FileLineRange().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileLineRange().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileLineRange().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FileLineRange, a, b); + } +}; +var TextBlock = class _TextBlock extends Message { + /** + * @generated from field: string content = 1; + */ + content = ''; + /** + * @generated from oneof exa.codeium_common_pb.TextBlock.identifier + */ + identifier = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TextBlock'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'file_line_range', + kind: 'message', + T: FileLineRange, + oneof: 'identifier', + }, + { no: 3, name: 'label', kind: 'scalar', T: 9, oneof: 'identifier' }, + ]); + static fromBinary(bytes, options) { + return new _TextBlock().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TextBlock().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TextBlock().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TextBlock, a, b); + } +}; +var RepositoryScopeItem = class _RepositoryScopeItem extends Message { + /** + * @generated from field: exa.codeium_common_pb.GitRepoInfo repo_info = 1; + */ + repoInfo; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.RepositoryScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'repo_info', kind: 'message', T: GitRepoInfo }, + ]); + static fromBinary(bytes, options) { + return new _RepositoryScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RepositoryScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RepositoryScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RepositoryScopeItem, a, b); + } +}; +var RepositoryPathScopeItem = class _RepositoryPathScopeItem extends Message { + /** + * @generated from field: exa.codeium_common_pb.GitRepoInfo repo_info = 1; + */ + repoInfo; + /** + * @generated from field: string relative_path = 2; + */ + relativePath = ''; + /** + * @generated from field: bool is_dir = 3; + */ + isDir = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.RepositoryPathScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'repo_info', kind: 'message', T: GitRepoInfo }, + { + no: 2, + name: 'relative_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'is_dir', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _RepositoryPathScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RepositoryPathScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RepositoryPathScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RepositoryPathScopeItem, a, b); + } +}; +var KnowledgeBaseScopeItem = class _KnowledgeBaseScopeItem extends Message { + /** + * Internal fields for retrieval. + * + * @generated from field: string document_id = 1; + */ + documentId = ''; + /** + * @generated from field: exa.codeium_common_pb.IndexChoice index = 7; + */ + index = IndexChoice.UNSPECIFIED; + /** + * @generated from field: exa.codeium_common_pb.DocumentType document_type = 8; + */ + documentType = DocumentType.UNSPECIFIED; + /** + * User facing fields. + * + * @generated from field: string display_name = 3; + */ + displayName = ''; + /** + * @generated from field: string description = 4; + */ + description = ''; + /** + * @generated from field: string display_source = 5; + */ + displaySource = ''; + /** + * Url to the knowledge base item if available. + * + * @generated from field: string url = 6; + */ + url = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.KnowledgeBaseScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'document_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 7, name: 'index', kind: 'enum', T: proto3.getEnumType(IndexChoice) }, + { + no: 8, + name: 'document_type', + kind: 'enum', + T: proto3.getEnumType(DocumentType), + }, + { + no: 3, + name: 'display_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'display_source', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeBaseScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeBaseScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeBaseScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeBaseScopeItem, a, b); + } +}; +var ConsoleLogLine = class _ConsoleLogLine extends Message { + /** + * Timestamp when the log was created. + * + * @generated from field: string timestamp_str = 1; + */ + timestampStr = ''; + /** + * Type of the log (error, warn, info, debug). + * + * @generated from field: string type = 2; + */ + type = ''; + /** + * Actual output of the log. + * + * @generated from field: string output = 3; + */ + output = ''; + /** + * Location of the log, including file path and line number, e.g., + * "third_party_upload_content_script.js:962:0". + * + * @generated from field: string location = 4; + */ + location = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ConsoleLogLine'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'timestamp_str', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'output', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'location', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ConsoleLogLine().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConsoleLogLine().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConsoleLogLine().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConsoleLogLine, a, b); + } +}; +var ConsoleLogScopeItem = class _ConsoleLogScopeItem extends Message { + /** + * Output of the console log. + * + * @generated from field: repeated exa.codeium_common_pb.ConsoleLogLine lines = 1; + */ + lines = []; + /** + * Address of web server (or proxy server). + * + * @generated from field: string server_address = 2; + */ + serverAddress = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ConsoleLogScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'lines', + kind: 'message', + T: ConsoleLogLine, + repeated: true, + }, + { + no: 2, + name: 'server_address', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ConsoleLogScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConsoleLogScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConsoleLogScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConsoleLogScopeItem, a, b); + } +}; +var DOMElementScopeItem = class _DOMElementScopeItem extends Message { + /** + * Tag name of the element (e.g. "div", "span", "button"). + * + * @generated from field: string tag_name = 1; + */ + tagName = ''; + /** + * Outer HTML of the element (may be truncated). + * + * @generated from field: string outer_html = 2; + */ + outerHtml = ''; + /** + * ID of the element (if applicable). + * + * @generated from field: string id = 3; + */ + id = ''; + /** + * Name of the containing React component (if applicable). + * + * @generated from field: string react_component_name = 4; + */ + reactComponentName = ''; + /** + * File line range (no end line) for the containing React component (if + * applicable). + * + * @generated from field: exa.codeium_common_pb.FileLineRange file_line_range = 5; + */ + fileLineRange; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DOMElementScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'tag_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'outer_html', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'react_component_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'file_line_range', kind: 'message', T: FileLineRange }, + ]); + static fromBinary(bytes, options) { + return new _DOMElementScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DOMElementScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DOMElementScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DOMElementScopeItem, a, b); + } +}; +var DOMNode = class _DOMNode extends Message { + /** + * @generated from field: bool is_visible = 1; + */ + isVisible = false; + /** + * @generated from oneof exa.codeium_common_pb.DOMNode.node_data + */ + nodeData = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DOMNode'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'is_visible', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'element', + kind: 'message', + T: DOMNode_ElementNode, + oneof: 'node_data', + }, + { + no: 3, + name: 'text', + kind: 'message', + T: DOMNode_TextNode, + oneof: 'node_data', + }, + ]); + static fromBinary(bytes, options) { + return new _DOMNode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DOMNode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DOMNode().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DOMNode, a, b); + } +}; +var DOMNode_ElementNode = class _DOMNode_ElementNode extends Message { + /** + * @generated from field: string tag_name = 1; + */ + tagName = ''; + /** + * @generated from field: string xpath = 2; + */ + xpath = ''; + /** + * IDs of child nodes + * + * @generated from field: repeated string children = 3; + */ + children = []; + /** + * @generated from field: map attributes = 4; + */ + attributes = {}; + /** + * @generated from field: bool is_interactive = 5; + */ + isInteractive = false; + /** + * @generated from field: bool is_top_element = 6; + */ + isTopElement = false; + /** + * -1 if not highlighted + * + * @generated from field: int32 highlight_index = 7; + */ + highlightIndex = 0; + /** + * @generated from field: int32 central_x = 8; + */ + centralX = 0; + /** + * @generated from field: int32 central_y = 9; + */ + centralY = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DOMNode.ElementNode'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'tag_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'xpath', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'children', kind: 'scalar', T: 9, repeated: true }, + { + no: 4, + name: 'attributes', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { + no: 5, + name: 'is_interactive', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'is_top_element', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'highlight_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 8, + name: 'central_x', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 9, + name: 'central_y', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _DOMNode_ElementNode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DOMNode_ElementNode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DOMNode_ElementNode().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DOMNode_ElementNode, a, b); + } +}; +var DOMNode_TextNode = class _DOMNode_TextNode extends Message { + /** + * @generated from field: string text = 1; + */ + text = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DOMNode.TextNode'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _DOMNode_TextNode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DOMNode_TextNode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DOMNode_TextNode().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DOMNode_TextNode, a, b); + } +}; +var DOMTree = class _DOMTree extends Message { + /** + * Root node ID in the DOM tree. + * + * @generated from field: string root_id = 1; + */ + rootId = ''; + /** + * Map from node ID to DOM node. + * + * @generated from field: map map = 2; + */ + map = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DOMTree'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'root_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'map', + kind: 'map', + K: 9, + V: { kind: 'message', T: DOMNode }, + }, + ]); + static fromBinary(bytes, options) { + return new _DOMTree().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DOMTree().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DOMTree().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DOMTree, a, b); + } +}; +var Viewport = class _Viewport extends Message { + /** + * X offset from the left edge + * + * @generated from field: int32 x = 1; + */ + x = 0; + /** + * Y offset from the top edge + * + * @generated from field: int32 y = 2; + */ + y = 0; + /** + * Width of the region + * + * @generated from field: int32 width = 3; + */ + width = 0; + /** + * Height of the region + * + * @generated from field: int32 height = 4; + */ + height = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Viewport'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'x', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'y', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'width', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'height', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _Viewport().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Viewport().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Viewport().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Viewport, a, b); + } +}; +var RecipeScopeItem = class _RecipeScopeItem extends Message { + /** + * @generated from field: string recipe_id = 1; + */ + recipeId = ''; + /** + * @generated from field: string title = 2; + */ + title = ''; + /** + * @generated from field: string description = 3; + */ + description = ''; + /** + * @generated from field: string system_prompt = 4; + */ + systemPrompt = ''; + /** + * Optional URI to the file containing the workflow (formerly known as a + * recipe). + * + * @generated from field: optional string uri = 5; + */ + uri; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.RecipeScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'recipe_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'system_prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'uri', kind: 'scalar', T: 9, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _RecipeScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RecipeScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RecipeScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RecipeScopeItem, a, b); + } +}; +var RuleScopeItem = class _RuleScopeItem extends Message { + /** + * @generated from field: string rule_path = 1; + */ + rulePath = ''; + /** + * @generated from field: string rule_name = 2; + */ + ruleName = ''; + /** + * TODO(sean): This is actually the content, will rename after cut to minimize + * risk of bricking my local state + * + * @generated from field: string description = 3; + */ + description = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.RuleScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'rule_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'rule_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _RuleScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RuleScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RuleScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RuleScopeItem, a, b); + } +}; +var McpResourceItem = class _McpResourceItem extends Message { + /** + * @generated from field: string uri = 1; + */ + uri = ''; + /** + * @generated from field: string name = 2; + */ + name = ''; + /** + * @generated from field: optional string description = 3; + */ + description; + /** + * @generated from field: optional string mime_type = 4; + */ + mimeType; + /** + * @generated from field: string server_name = 5; + */ + serverName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.McpResourceItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'description', kind: 'scalar', T: 9, opt: true }, + { no: 4, name: 'mime_type', kind: 'scalar', T: 9, opt: true }, + { + no: 5, + name: 'server_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _McpResourceItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpResourceItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpResourceItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpResourceItem, a, b); + } +}; +var BrowserPageScopeItem = class _BrowserPageScopeItem extends Message { + /** + * URL of the page + * + * @generated from field: string url = 1; + */ + url = ''; + /** + * Title of the page + * + * @generated from field: string title = 2; + */ + title = ''; + /** + * All visible text content from the page + * + * @generated from field: string visible_text_content = 3; + */ + visibleTextContent = ''; + /** + * ID of the page in the browser session + * + * @generated from field: string page_id = 4; + */ + pageId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.BrowserPageScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'visible_text_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserPageScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserPageScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserPageScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserPageScopeItem, a, b); + } +}; +var BrowserCodeBlockScopeItem = class _BrowserCodeBlockScopeItem extends Message { + /** + * URL of the page where the code block is located + * + * @generated from field: string url = 1; + */ + url = ''; + /** + * Title of the page + * + * @generated from field: string title = 2; + */ + title = ''; + /** + * The text content of the code block + * + * @generated from field: string code_content = 3; + */ + codeContent = ''; + /** + * Detected or user-specified language of the code + * + * @generated from field: exa.codeium_common_pb.Language language = 4; + */ + language = Language.UNSPECIFIED; + /** + * Optional text surrounding the code block + * + * @generated from field: optional string context_text = 5; + */ + contextText; + /** + * ID of the page in the browser session + * + * @generated from field: string page_id = 6; + */ + pageId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.BrowserCodeBlockScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'code_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { no: 5, name: 'context_text', kind: 'scalar', T: 9, opt: true }, + { + no: 6, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserCodeBlockScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserCodeBlockScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserCodeBlockScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserCodeBlockScopeItem, a, b); + } +}; +var BrowserTextScopeItem = class _BrowserTextScopeItem extends Message { + /** + * URL of the page containing the element + * + * @generated from field: string url = 1; + */ + url = ''; + /** + * The inner text content of the selected element + * + * @generated from field: string visible_text = 2; + */ + visibleText = ''; + /** + * ID of the page in the browser session + * + * @generated from field: string page_id = 3; + */ + pageId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.BrowserTextScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'visible_text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserTextScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserTextScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserTextScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserTextScopeItem, a, b); + } +}; +var ConversationScopeItem = class _ConversationScopeItem extends Message { + /** + * Cascade ID + * + * @generated from field: string id = 1; + */ + id = ''; + /** + * Conversation title + * + * @generated from field: string title = 2; + */ + title = ''; + /** + * Last modified time + * + * @generated from field: google.protobuf.Timestamp last_modified_time = 3; + */ + lastModifiedTime; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ConversationScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'last_modified_time', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _ConversationScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConversationScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConversationScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConversationScopeItem, a, b); + } +}; +var UserActivityScopeItem = class _UserActivityScopeItem extends Message { + /** + * Trajectory ID + * + * @generated from field: string id = 1; + */ + id = ''; + /** + * Git branch associated with activity ("" if there is no branch) + * + * @generated from field: string branch = 2; + */ + branch = ''; + /** + * Whether this is the active trajectory for an active workspace + * + * @generated from field: bool current = 3; + */ + current = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.UserActivityScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'branch', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'current', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _UserActivityScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserActivityScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserActivityScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserActivityScopeItem, a, b); + } +}; +var TerminalScopeItem = class _TerminalScopeItem extends Message { + /** + * Process ID of the terminal + * + * @generated from field: string process_id = 1; + */ + processId = ''; + /** + * Terminal name + * + * @generated from field: string name = 2; + */ + name = ''; + /** + * Last command executed in the terminal + * + * @generated from field: string last_command = 3; + */ + lastCommand = ''; + /** + * Content of some selection within the terminal buffer. + * + * @generated from field: optional string selectionContent = 4; + */ + selectionContent; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TerminalScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'process_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'last_command', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'selectionContent', kind: 'scalar', T: 9, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _TerminalScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TerminalScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TerminalScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TerminalScopeItem, a, b); + } +}; +var ContextScopeItem = class _ContextScopeItem extends Message { + /** + * @generated from oneof exa.codeium_common_pb.ContextScopeItem.scope_item + */ + scopeItem = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ContextScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'file', + kind: 'message', + T: PathScopeItem, + oneof: 'scope_item', + }, + { + no: 2, + name: 'directory', + kind: 'message', + T: PathScopeItem, + oneof: 'scope_item', + }, + { + no: 3, + name: 'repository', + kind: 'message', + T: RepositoryScopeItem, + oneof: 'scope_item', + }, + { + no: 4, + name: 'code_context', + kind: 'message', + T: CodeContextItem, + oneof: 'scope_item', + }, + { + no: 6, + name: 'cci_with_subrange', + kind: 'message', + T: CciWithSubrange, + oneof: 'scope_item', + }, + { + no: 7, + name: 'repository_path', + kind: 'message', + T: RepositoryPathScopeItem, + oneof: 'scope_item', + }, + { + no: 8, + name: 'slack', + kind: 'message', + T: KnowledgeBaseScopeItem, + oneof: 'scope_item', + }, + { + no: 9, + name: 'github', + kind: 'message', + T: KnowledgeBaseScopeItem, + oneof: 'scope_item', + }, + { + no: 10, + name: 'file_line_range', + kind: 'message', + T: FileLineRange, + oneof: 'scope_item', + }, + { + no: 11, + name: 'text_block', + kind: 'message', + T: TextBlock, + oneof: 'scope_item', + }, + { + no: 12, + name: 'jira', + kind: 'message', + T: KnowledgeBaseScopeItem, + oneof: 'scope_item', + }, + { + no: 13, + name: 'google_drive', + kind: 'message', + T: KnowledgeBaseScopeItem, + oneof: 'scope_item', + }, + { + no: 14, + name: 'console_log', + kind: 'message', + T: ConsoleLogScopeItem, + oneof: 'scope_item', + }, + { + no: 15, + name: 'dom_element', + kind: 'message', + T: DOMElementScopeItem, + oneof: 'scope_item', + }, + { + no: 16, + name: 'recipe', + kind: 'message', + T: RecipeScopeItem, + oneof: 'scope_item', + }, + { + no: 17, + name: 'knowledge', + kind: 'message', + T: KnowledgeBaseScopeItem, + oneof: 'scope_item', + }, + { + no: 18, + name: 'rule', + kind: 'message', + T: RuleScopeItem, + oneof: 'scope_item', + }, + { + no: 19, + name: 'mcp_resource', + kind: 'message', + T: McpResourceItem, + oneof: 'scope_item', + }, + { + no: 20, + name: 'browser_page', + kind: 'message', + T: BrowserPageScopeItem, + oneof: 'scope_item', + }, + { + no: 21, + name: 'browser_code_block', + kind: 'message', + T: BrowserCodeBlockScopeItem, + oneof: 'scope_item', + }, + { + no: 22, + name: 'browser_text', + kind: 'message', + T: BrowserTextScopeItem, + oneof: 'scope_item', + }, + { + no: 23, + name: 'conversation', + kind: 'message', + T: ConversationScopeItem, + oneof: 'scope_item', + }, + { + no: 24, + name: 'user_activity', + kind: 'message', + T: UserActivityScopeItem, + oneof: 'scope_item', + }, + { + no: 25, + name: 'terminal', + kind: 'message', + T: TerminalScopeItem, + oneof: 'scope_item', + }, + ]); + static fromBinary(bytes, options) { + return new _ContextScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ContextScopeItem, a, b); + } +}; +var ContextScope = class _ContextScope extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.ContextScopeItem items = 1; + */ + items = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ContextScope'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'items', + kind: 'message', + T: ContextScopeItem, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ContextScope().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextScope().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextScope().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ContextScope, a, b); + } +}; +var NodeExecutionRecord = class _NodeExecutionRecord extends Message { + /** + * @generated from field: string node_name = 1; + */ + nodeName = ''; + /** + * @generated from field: google.protobuf.Timestamp start_time = 2; + */ + startTime; + /** + * @generated from field: google.protobuf.Timestamp end_time = 3; + */ + endTime; + /** + * Serialized state of the graph at the end of this node. + * + * @generated from field: bytes graph_state_json = 5; + */ + graphStateJson = new Uint8Array(0); + /** + * @generated from field: uint64 graph_state_json_num_bytes = 6; + */ + graphStateJsonNumBytes = protoInt64.zero; + /** + * Optionally provided if the node is running a sub-graph. + * + * @generated from field: exa.codeium_common_pb.GraphExecutionState subgraph_execution = 4; + */ + subgraphExecution; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.NodeExecutionRecord'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'node_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'start_time', kind: 'message', T: Timestamp }, + { no: 3, name: 'end_time', kind: 'message', T: Timestamp }, + { + no: 5, + name: 'graph_state_json', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + { + no: 6, + name: 'graph_state_json_num_bytes', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 4, + name: 'subgraph_execution', + kind: 'message', + T: GraphExecutionState, + }, + ]); + static fromBinary(bytes, options) { + return new _NodeExecutionRecord().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _NodeExecutionRecord().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _NodeExecutionRecord().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_NodeExecutionRecord, a, b); + } +}; +var GraphExecutionState = class _GraphExecutionState extends Message { + /** + * @generated from field: exa.codeium_common_pb.NodeExecutionRecord current = 1; + */ + current; + /** + * @generated from field: repeated exa.codeium_common_pb.NodeExecutionRecord history = 2; + */ + history = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.GraphExecutionState'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'current', kind: 'message', T: NodeExecutionRecord }, + { + no: 2, + name: 'history', + kind: 'message', + T: NodeExecutionRecord, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GraphExecutionState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GraphExecutionState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GraphExecutionState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GraphExecutionState, a, b); + } +}; +var Guideline = class _Guideline extends Message { + /** + * GuidelineItem is a free form guideline attached as a context to chat, + * command and autocomplete + * + * @generated from field: repeated exa.codeium_common_pb.GuidelineItem items = 1; + */ + items = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Guideline'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'items', kind: 'message', T: GuidelineItem, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _Guideline().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Guideline().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Guideline().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Guideline, a, b); + } +}; +var GuidelineItem = class _GuidelineItem extends Message { + /** + * Free form guideline applied as a context item + * + * @generated from field: string guideline = 1; + */ + guideline = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.GuidelineItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'guideline', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _GuidelineItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GuidelineItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GuidelineItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GuidelineItem, a, b); + } +}; +var ChatNodeConfig = class _ChatNodeConfig extends Message { + /** + * @generated from field: exa.codeium_common_pb.Model model = 1; + */ + model = Model.UNSPECIFIED; + /** + * TODO(matt): Move these settings under CompletionConfiguration. + * + * @generated from field: uint32 max_input_tokens = 2; + */ + maxInputTokens = 0; + /** + * @generated from field: float temperature = 3; + */ + temperature = 0; + /** + * @generated from field: uint32 max_output_tokens = 4; + */ + maxOutputTokens = 0; + /** + * @generated from field: bool order_snippets_by_file = 5; + */ + orderSnippetsByFile = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ChatNodeConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'model', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 2, + name: 'max_input_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'temperature', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 4, + name: 'max_output_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'order_snippets_by_file', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatNodeConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatNodeConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatNodeConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatNodeConfig, a, b); + } +}; +var MQueryConfig = class _MQueryConfig extends Message { + /** + * @generated from field: bool should_batch_ccis = 1; + */ + shouldBatchCcis = false; + /** + * @generated from field: int64 max_tokens_per_subrange = 2; + */ + maxTokensPerSubrange = protoInt64.zero; + /** + * @generated from field: int64 num_parser_workers = 3; + */ + numParserWorkers = protoInt64.zero; + /** + * @generated from field: int64 num_workers_per_distributed_scorer = 4; + */ + numWorkersPerDistributedScorer = protoInt64.zero; + /** + * @generated from field: bool verbose = 5; + */ + verbose = false; + /** + * Files with these extensions should be ignored + * + * @generated from field: repeated string ignore_extensions = 6; + */ + ignoreExtensions = []; + /** + * Directories that include this in their path should be ignored. + * + * @generated from field: repeated string ignore_directory_stubs = 7; + */ + ignoreDirectoryStubs = []; + /** + * @generated from field: uint32 min_token_space_for_context = 8; + */ + minTokenSpaceForContext = 0; + /** + * Bounded by MaxMaxTargetFiles (10_000) + * + * @generated from field: uint32 max_target_files = 9; + */ + maxTargetFiles = 0; + /** + * Will filter out ccis outside of the top count. + * + * @generated from field: uint32 top_cci_count = 10; + */ + topCciCount = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.MQueryConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'should_batch_ccis', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'max_tokens_per_subrange', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 3, + name: 'num_parser_workers', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 4, + name: 'num_workers_per_distributed_scorer', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 5, + name: 'verbose', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 6, name: 'ignore_extensions', kind: 'scalar', T: 9, repeated: true }, + { + no: 7, + name: 'ignore_directory_stubs', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 8, + name: 'min_token_space_for_context', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 9, + name: 'max_target_files', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 10, + name: 'top_cci_count', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _MQueryConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MQueryConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MQueryConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_MQueryConfig, a, b); + } +}; +var CompletionDelta = class _CompletionDelta extends Message { + /** + * @generated from field: string delta_text = 1; + */ + deltaText = ''; + /** + * @generated from field: string delta_raw_generation = 12; + */ + deltaRawGeneration = ''; + /** + * @generated from field: uint32 delta_tokens = 2; + */ + deltaTokens = 0; + /** + * The following are only populated on the last delta. + * + * @generated from field: exa.codeium_common_pb.StopReason stop_reason = 3; + */ + stopReason = StopReason.UNSPECIFIED; + /** + * Represents total usage in the entire request, not just this chunk. Only + * populated for a subset of external API providers. + * + * @generated from field: exa.codeium_common_pb.ModelUsageStats usage = 4; + */ + usage; + /** + * @generated from field: repeated exa.codeium_common_pb.ChatToolCall delta_tool_calls = 5; + */ + deltaToolCalls = []; + /** + * @generated from field: string delta_thinking = 6; + */ + deltaThinking = ''; + /** + * @generated from field: bytes delta_signature = 7; + */ + deltaSignature = new Uint8Array(0); + /** + * If this is true, then delta_signature is fully populated and this chunk + * should be interpreted as a full thinking_redacted delta. + * + * @generated from field: bool thinking_redacted = 8; + */ + thinkingRedacted = false; + /** + * Represents the new Recitations for the accumulated raw_generation + * + * @generated from field: exa.codeium_common_pb.CitationMetadata citation_metadata = 11; + */ + citationMetadata; + /** + * Dapper trace ID from the upstream API response. + * + * @generated from field: string trace_id = 13; + */ + traceId = ''; + /** + * Optional message from the model explaining the stop reason. + * Currently populated when Gemini API returns a finishMessage. + * + * @generated from field: string stop_message = 14; + */ + stopMessage = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionDelta'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'delta_text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'delta_raw_generation', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'delta_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'stop_reason', + kind: 'enum', + T: proto3.getEnumType(StopReason), + }, + { no: 4, name: 'usage', kind: 'message', T: ModelUsageStats }, + { + no: 5, + name: 'delta_tool_calls', + kind: 'message', + T: ChatToolCall, + repeated: true, + }, + { + no: 6, + name: 'delta_thinking', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'delta_signature', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + { + no: 8, + name: 'thinking_redacted', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 11, name: 'citation_metadata', kind: 'message', T: CitationMetadata }, + { + no: 13, + name: 'trace_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 14, + name: 'stop_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionDelta().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionDelta().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionDelta().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionDelta, a, b); + } +}; +var CompletionDeltaMap = class _CompletionDeltaMap extends Message { + /** + * A map of completion index (within a sequence) to CompletionDelta messages. + * Note that not all completions may be included in this map, if some of them + * finish early. (For example, our internal model API client will only + * include CompletionDeltas for completions that have not yet finished.) + * + * @generated from field: map deltas = 1; + */ + deltas = {}; + /** + * The prompt string that was generated by the model API client. This will be + * empty unless the api server was constructed with EvalMode == true, in which + * case it will be populated for the first CompletionDeltaMap that is + * returned. Note that this is best-effort, as we may not be able to construct + * the true prompt string used by some API providers. Currently only + * implemented for our internal model API client; prompt will be empty for + * other providers. + * + * @generated from field: string prompt = 2; + */ + prompt = ''; + /** + * CompletionProfile contains latency profiling info for the completions + * This is guaranteed to be populated in at most one response delta (the last + * one for internal inference servers). + * + * @generated from field: exa.codeium_common_pb.CompletionProfile completion_profile = 3; + */ + completionProfile; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CompletionDeltaMap'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'deltas', + kind: 'map', + K: 5, + V: { kind: 'message', T: CompletionDelta }, + }, + { + no: 2, + name: 'prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'completion_profile', + kind: 'message', + T: CompletionProfile, + }, + ]); + static fromBinary(bytes, options) { + return new _CompletionDeltaMap().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CompletionDeltaMap().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CompletionDeltaMap().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CompletionDeltaMap, a, b); + } +}; +var ChatCompletionInfo = class _ChatCompletionInfo extends Message { + /** + * @generated from field: string prompt = 1; + */ + prompt = ''; + /** + * @generated from field: string inference_address = 2; + */ + inferenceAddress = ''; + /** + * @generated from field: string serialized_prompt = 3; + */ + serializedPrompt = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ChatCompletionInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'inference_address', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'serialized_prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatCompletionInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatCompletionInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatCompletionInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatCompletionInfo, a, b); + } +}; +var ChatToolCall = class _ChatToolCall extends Message { + /** + * @generated from field: string id = 1; + */ + id = ''; + /** + * @generated from field: string name = 2; + */ + name = ''; + /** + * @generated from field: string arguments_json = 3; + */ + argumentsJson = ''; + /** + * If the JSON provided in the tool call is invalid, then arguments_json will + * be {} and the underlying invalid_json_str will contain the raw invalid + * json. Otherwise if the JSON is valid, then invalid_json_str and + * invalid_json_err will be empty. + * + * @generated from field: string invalid_json_str = 4; + */ + invalidJsonStr = ''; + /** + * Error message describing why the json is invalid. + * + * @generated from field: string invalid_json_err = 5; + */ + invalidJsonErr = ''; + /** + * Gemini API can return thought signatures in function call parts, so we + * need to save it in the tool call too. + * Deprecated. Use thinking_signature instead. + * + * @generated from field: string thought_signature = 6 [deprecated = true]; + * @deprecated + */ + thoughtSignature = ''; + /** + * @generated from field: bytes thinking_signature = 7; + */ + thinkingSignature = new Uint8Array(0); + /** + * Because we allow overriding tool arguments, we map the arguments_json to + * the original argument names in order for tool parsing to work. We preserve + * the original arguments_json here. + * + * @generated from field: string original_arguments_json = 8; + */ + originalArgumentsJson = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ChatToolCall'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'arguments_json', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'invalid_json_str', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'invalid_json_err', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'thought_signature', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'thinking_signature', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + { + no: 8, + name: 'original_arguments_json', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatToolCall().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatToolCall().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatToolCall().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatToolCall, a, b); + } +}; +var Status = class _Status extends Message { + /** + * @generated from field: exa.codeium_common_pb.StatusLevel level = 1; + */ + level = StatusLevel.UNSPECIFIED; + /** + * @generated from field: string message = 2; + */ + message = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Status'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'level', kind: 'enum', T: proto3.getEnumType(StatusLevel) }, + { + no: 2, + name: 'message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _Status().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Status().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Status().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Status, a, b); + } +}; +var DocumentPosition = class _DocumentPosition extends Message { + /** + * 0-indexed. + * + * @generated from field: uint64 row = 1; + */ + row = protoInt64.zero; + /** + * 0-indexed. Measured in UTF-8 bytes. + * + * @generated from field: uint64 col = 2; + */ + col = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DocumentPosition'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'row', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'col', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _DocumentPosition().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DocumentPosition().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DocumentPosition().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DocumentPosition, a, b); + } +}; +var Range = class _Range extends Message { + /** + * 0-indexed (start & end). + * + * @generated from field: uint64 start_offset = 1; + */ + startOffset = protoInt64.zero; + /** + * Exclusive. + * + * @generated from field: uint64 end_offset = 2; + */ + endOffset = protoInt64.zero; + /** + * @generated from field: exa.codeium_common_pb.DocumentPosition start_position = 3; + */ + startPosition; + /** + * Exclusive. + * + * @generated from field: exa.codeium_common_pb.DocumentPosition end_position = 4; + */ + endPosition; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Range'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'start_offset', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'end_offset', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { no: 3, name: 'start_position', kind: 'message', T: DocumentPosition }, + { no: 4, name: 'end_position', kind: 'message', T: DocumentPosition }, + ]); + static fromBinary(bytes, options) { + return new _Range().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Range().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Range().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Range, a, b); + } +}; +var Document = class _Document extends Message { + /** + * OS specific separators. + * + * @generated from field: string absolute_path_migrate_me_to_uri = 1 [deprecated = true]; + * @deprecated + */ + absolutePathMigrateMeToUri = ''; + /** + * @generated from field: string absolute_uri = 12; + */ + absoluteUri = ''; + /** + * Path relative to the root of the workspace. Slash separated. + * Leave empty if the document is not in the workspace. + * + * @generated from field: string relative_path_migrate_me_to_workspace_uri = 2 [deprecated = true]; + * @deprecated + */ + relativePathMigrateMeToWorkspaceUri = ''; + /** + * @generated from field: string workspace_uri = 13; + */ + workspaceUri = ''; + /** + * @generated from field: string text = 3; + */ + text = ''; + /** + * Language ID provided by the editor. + * + * @generated from field: string editor_language = 4; + */ + editorLanguage = ''; + /** + * Language enum standardized across editors. + * + * @generated from field: exa.codeium_common_pb.Language language = 5; + */ + language = Language.UNSPECIFIED; + /** + * Measured in number of UTF-8 bytes. + * + * @generated from field: uint64 cursor_offset = 6; + */ + cursorOffset = protoInt64.zero; + /** + * May be present instead of cursor_offset. + * + * @generated from field: exa.codeium_common_pb.DocumentPosition cursor_position = 8; + */ + cursorPosition; + /** + * \n or \r\n, if known. + * + * @generated from field: string line_ending = 7; + */ + lineEnding = ''; + /** + * Portion of document visible in IDE; + * + * @generated from field: exa.codeium_common_pb.Range visible_range = 9; + */ + visibleRange; + /** + * Booleans indicating whether this document represents a portion of a full + * document with the start / end cutoff. Note that cursor_offset and + * cursor_position are expected to be valid within text (e.g. if the start of + * the document is cutoff in text, cursor_offset and cursor_position should be + * adjusted accordingly). + * TODO(nmoy): deprecate these bools now that we have + * lines_cutoff_start/lines_cutoff_end. + * + * @generated from field: bool is_cutoff_start = 10; + */ + isCutoffStart = false; + /** + * @generated from field: bool is_cutoff_end = 11; + */ + isCutoffEnd = false; + /** + * The number of lines from the original document that are cut off and not + * included in this partial document. If these values are non-zero that means + * that this is a partial document. If it has not been cutoff, these should + * both be equal 0. + * + * @generated from field: int32 lines_cutoff_start = 14; + */ + linesCutoffStart = 0; + /** + * @generated from field: int32 lines_cutoff_end = 15; + */ + linesCutoffEnd = 0; + /** + * Timestamp at which document content was read. + * + * @generated from field: google.protobuf.Timestamp timestamp = 16; + */ + timestamp; + /** + * True if there are unpersisted changes to the document. + * + * @generated from field: bool is_dirty = 17; + */ + isDirty = false; + /** + * True if the document is not a real document, e.g. chat input. + * + * @generated from field: bool is_synthetic = 18; + */ + isSynthetic = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Document'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_path_migrate_me_to_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'relative_path_migrate_me_to_workspace_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 13, + name: 'workspace_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'editor_language', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { + no: 6, + name: 'cursor_offset', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { no: 8, name: 'cursor_position', kind: 'message', T: DocumentPosition }, + { + no: 7, + name: 'line_ending', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 9, name: 'visible_range', kind: 'message', T: Range }, + { + no: 10, + name: 'is_cutoff_start', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 11, + name: 'is_cutoff_end', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 14, + name: 'lines_cutoff_start', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 15, + name: 'lines_cutoff_end', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { no: 16, name: 'timestamp', kind: 'message', T: Timestamp }, + { + no: 17, + name: 'is_dirty', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 18, + name: 'is_synthetic', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _Document().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Document().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Document().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Document, a, b); + } +}; +var PromptComponents = class _PromptComponents extends Message { + /** + * Note that these documents may not contain the entire document text. In + * order to limit the amount of data sent, the client may create a "fake" + * document for a section of text around the cursor. + * + * @generated from field: exa.codeium_common_pb.Document document = 1; + */ + document; + /** + * @generated from field: repeated exa.codeium_common_pb.Document other_documents = 2; + */ + otherDocuments = []; + /** + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem code_context_items = 3; + */ + codeContextItems = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PromptComponents'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'document', kind: 'message', T: Document }, + { + no: 2, + name: 'other_documents', + kind: 'message', + T: Document, + repeated: true, + }, + { + no: 3, + name: 'code_context_items', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _PromptComponents().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptComponents().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptComponents().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PromptComponents, a, b); + } +}; +var TextOrScopeItem = class _TextOrScopeItem extends Message { + /** + * @generated from oneof exa.codeium_common_pb.TextOrScopeItem.chunk + */ + chunk = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TextOrScopeItem'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'text', kind: 'scalar', T: 9, oneof: 'chunk' }, + { + no: 2, + name: 'item', + kind: 'message', + T: ContextScopeItem, + oneof: 'chunk', + }, + ]); + static fromBinary(bytes, options) { + return new _TextOrScopeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TextOrScopeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TextOrScopeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TextOrScopeItem, a, b); + } +}; +var PinnedContextConfig = class _PinnedContextConfig extends Message { + /** + * Exact match repo name + * + * @generated from field: string match_repo_name = 1; + */ + matchRepoName = ''; + /** + * Prefix match path. + * + * @generated from field: string match_path = 2; + */ + matchPath = ''; + /** + * @generated from field: repeated exa.codeium_common_pb.PinnedContext pinned_contexts = 3; + */ + pinnedContexts = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PinnedContextConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'match_repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'match_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'pinned_contexts', + kind: 'message', + T: PinnedContext, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _PinnedContextConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PinnedContextConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PinnedContextConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PinnedContextConfig, a, b); + } +}; +var PinnedContext = class _PinnedContext extends Message { + /** + * @generated from oneof exa.codeium_common_pb.PinnedContext.context_item + */ + contextItem = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PinnedContext'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'repository_path', + kind: 'message', + T: RepositoryPath, + oneof: 'context_item', + }, + ]); + static fromBinary(bytes, options) { + return new _PinnedContext().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PinnedContext().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PinnedContext().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PinnedContext, a, b); + } +}; +var RepositoryPath = class _RepositoryPath extends Message { + /** + * @generated from field: string remote_repo_name = 1; + */ + remoteRepoName = ''; + /** + * empty string for latest + * + * @generated from field: string version = 2; + */ + version = ''; + /** + * empty string for relative_path will pin the whole repo instead + * + * @generated from field: string relative_path = 3; + */ + relativePath = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.RepositoryPath'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'remote_repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'version', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'relative_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _RepositoryPath().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RepositoryPath().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RepositoryPath().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RepositoryPath, a, b); + } +}; +var DefaultPinnedContextConfig = class _DefaultPinnedContextConfig extends Message { + /** + * Empty string applies to project without a git repo + * + * @generated from field: repeated exa.codeium_common_pb.PinnedContextConfig pinned_context_configs = 1; + */ + pinnedContextConfigs = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DefaultPinnedContextConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'pinned_context_configs', + kind: 'message', + T: PinnedContextConfig, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _DefaultPinnedContextConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DefaultPinnedContextConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DefaultPinnedContextConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_DefaultPinnedContextConfig, a, b); + } +}; +var Rule = class _Rule extends Message { + /** + * @generated from field: string id = 1; + */ + id = ''; + /** + * @generated from field: string prompt = 2; + */ + prompt = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Rule'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _Rule().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Rule().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Rule().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Rule, a, b); + } +}; +var RuleViolation = class _RuleViolation extends Message { + /** + * @generated from field: string id = 1; + */ + id = ''; + /** + * @generated from field: exa.codeium_common_pb.Rule rule = 2; + */ + rule; + /** + * @generated from field: int32 start_line = 3; + */ + startLine = 0; + /** + * @generated from field: int32 end_line = 4; + */ + endLine = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.RuleViolation'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'rule', kind: 'message', T: Rule }, + { + no: 3, + name: 'start_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'end_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _RuleViolation().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RuleViolation().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RuleViolation().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RuleViolation, a, b); + } +}; +var LanguageServerDiagnostics = class _LanguageServerDiagnostics extends Message { + /** + * @generated from field: repeated string logs = 1; + */ + logs = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.LanguageServerDiagnostics'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'logs', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _LanguageServerDiagnostics().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LanguageServerDiagnostics().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LanguageServerDiagnostics().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LanguageServerDiagnostics, a, b); + } +}; +var IndexerStats = class _IndexerStats extends Message { + /** + * @generated from field: exa.codeium_common_pb.IndexerDbStats database = 1; + */ + database; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.IndexerStats'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'database', kind: 'message', T: IndexerDbStats }, + ]); + static fromBinary(bytes, options) { + return new _IndexerStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexerStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexerStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexerStats, a, b); + } +}; +var IndexerDbStats = class _IndexerDbStats extends Message { + /** + * @generated from oneof exa.codeium_common_pb.IndexerDbStats.backend + */ + backend = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.IndexerDbStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'local_sqlite_faiss', + kind: 'message', + T: LocalSqliteFaissDbStats, + oneof: 'backend', + }, + { + no: 2, + name: 'postgres', + kind: 'message', + T: PostgresDbStats, + oneof: 'backend', + }, + ]); + static fromBinary(bytes, options) { + return new _IndexerDbStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexerDbStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexerDbStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexerDbStats, a, b); + } +}; +var LocalSqliteFaissDbStats = class _LocalSqliteFaissDbStats extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.FaissStateStats faiss_state_stats = 1; + */ + faissStateStats = []; + /** + * @generated from field: int64 total_item_count = 2; + */ + totalItemCount = protoInt64.zero; + /** + * @generated from field: bool quantized = 3; + */ + quantized = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.LocalSqliteFaissDbStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'faiss_state_stats', + kind: 'message', + T: FaissStateStats, + repeated: true, + }, + { + no: 2, + name: 'total_item_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 3, + name: 'quantized', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _LocalSqliteFaissDbStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LocalSqliteFaissDbStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LocalSqliteFaissDbStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LocalSqliteFaissDbStats, a, b); + } +}; +var FaissStateStats = class _FaissStateStats extends Message { + /** + * @generated from field: exa.codeium_common_pb.EmbeddingSource embedding_source = 1; + */ + embeddingSource = EmbeddingSource.UNSPECIFIED; + /** + * @generated from field: string workspace = 2; + */ + workspace = ''; + /** + * @generated from field: int64 item_count = 3; + */ + itemCount = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.FaissStateStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'embedding_source', + kind: 'enum', + T: proto3.getEnumType(EmbeddingSource), + }, + { + no: 2, + name: 'workspace', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'item_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _FaissStateStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FaissStateStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FaissStateStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FaissStateStats, a, b); + } +}; +var PostgresDbStats = class _PostgresDbStats extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PostgresDbStats'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _PostgresDbStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PostgresDbStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PostgresDbStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PostgresDbStats, a, b); + } +}; +var LastUpdateRecord = class _LastUpdateRecord extends Message { + /** + * @generated from field: google.protobuf.Timestamp time = 1; + */ + time; + /** + * @generated from field: exa.codeium_common_pb.LastUpdateType type = 2; + */ + type = LastUpdateType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.LastUpdateRecord'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'time', kind: 'message', T: Timestamp }, + { + no: 2, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(LastUpdateType), + }, + ]); + static fromBinary(bytes, options) { + return new _LastUpdateRecord().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LastUpdateRecord().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LastUpdateRecord().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LastUpdateRecord, a, b); + } +}; +var ModelUsageStats = class _ModelUsageStats extends Message { + /** + * @generated from field: exa.codeium_common_pb.Model model = 1; + */ + model = Model.UNSPECIFIED; + /** + * The number of input tokens written to cache. + * + * @generated from field: uint64 input_tokens = 2; + */ + inputTokens = protoInt64.zero; + /** + * For multiple completions, this should be interpreted as the sum of all + * outputs. + * + * @generated from field: uint64 output_tokens = 3; + */ + outputTokens = protoInt64.zero; + /** + * For requests with thinking, this should be interpreted as the sum of all + * thinking outputs. Will be 0 if there is no thinking. + * + * @generated from field: uint64 thinking_output_tokens = 9; + */ + thinkingOutputTokens = protoInt64.zero; + /** + * The number of output tokens for the response, excluding thinking tokens if + * applicable. + * + * @generated from field: uint64 response_output_tokens = 10; + */ + responseOutputTokens = protoInt64.zero; + /** + * The number of tokens successfully read from the cache. + * + * @generated from field: uint64 cache_read_tokens = 5; + */ + cacheReadTokens = protoInt64.zero; + /** + * @generated from field: exa.codeium_common_pb.APIProvider api_provider = 6; + */ + apiProvider = APIProvider.API_PROVIDER_UNSPECIFIED; + /** + * External message id for this request. + * + * @generated from field: string message_id = 7; + */ + messageId = ''; + /** + * Response headers from the API provider. + * + * @generated from field: map response_header = 8; + */ + responseHeader = {}; + /** + * Identifier for the API request/response. + * + * @generated from field: string response_id = 11; + */ + responseId = ''; + /** + * No longer being used after moving to GDM. + * + * @generated from field: uint64 cache_write_tokens = 4 [deprecated = true]; + * @deprecated + */ + cacheWriteTokens = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ModelUsageStats'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'model', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 2, + name: 'input_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'output_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 9, + name: 'thinking_output_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 10, + name: 'response_output_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 5, + name: 'cache_read_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 6, + name: 'api_provider', + kind: 'enum', + T: proto3.getEnumType(APIProvider), + }, + { + no: 7, + name: 'message_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'response_header', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { + no: 11, + name: 'response_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'cache_write_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ModelUsageStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelUsageStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ModelUsageStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ModelUsageStats, a, b); + } +}; +var SuperCompleteFilterReason = class _SuperCompleteFilterReason extends Message { + /** + * @generated from field: string reason = 1; + */ + reason = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.SuperCompleteFilterReason'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'reason', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _SuperCompleteFilterReason().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SuperCompleteFilterReason().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SuperCompleteFilterReason().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SuperCompleteFilterReason, a, b); + } +}; +var CodeDiagnostic = class _CodeDiagnostic extends Message { + /** + * @generated from field: exa.codeium_common_pb.Range range = 1; + */ + range; + /** + * @generated from field: string message = 2; + */ + message = ''; + /** + * @generated from field: string severity = 3; + */ + severity = ''; + /** + * @generated from field: string source = 4; + */ + source = ''; + /** + * @generated from field: string uri = 5; + */ + uri = ''; + /** + * A unique ID to identify the diagnostic across its lifetime. + * + * @generated from field: optional string id = 6; + */ + id; + /** + * @generated from field: exa.codeium_common_pb.Language language = 7; + */ + language = Language.UNSPECIFIED; + /** + * A score of how relevant the diagnostic is to the active file, + * based on depth of the common path between their URIs. + * + * @generated from field: int64 score = 8; + */ + score = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CodeDiagnostic'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'range', kind: 'message', T: Range }, + { + no: 2, + name: 'message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'severity', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'source', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 6, name: 'id', kind: 'scalar', T: 9, opt: true }, + { no: 7, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { + no: 8, + name: 'score', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CodeDiagnostic().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeDiagnostic().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeDiagnostic().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeDiagnostic, a, b); + } +}; +var IntellisenseSuggestion = class _IntellisenseSuggestion extends Message { + /** + * @generated from field: exa.codeium_common_pb.Range range = 1; + */ + range; + /** + * @generated from field: string text = 2; + */ + text = ''; + /** + * @generated from field: string label = 3; + */ + label = ''; + /** + * @generated from field: string label_detail = 4; + */ + labelDetail = ''; + /** + * @generated from field: string description = 5; + */ + description = ''; + /** + * @generated from field: string detail = 6; + */ + detail = ''; + /** + * @generated from field: string documentation = 7; + */ + documentation = ''; + /** + * @generated from field: string kind = 8; + */ + kind = ''; + /** + * @generated from field: bool selected = 9; + */ + selected = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.IntellisenseSuggestion'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'range', kind: 'message', T: Range }, + { + no: 2, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'label', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'label_detail', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'detail', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'documentation', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'kind', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'selected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _IntellisenseSuggestion().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IntellisenseSuggestion().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IntellisenseSuggestion().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IntellisenseSuggestion, a, b); + } +}; +var DocumentLinesElement = class _DocumentLinesElement extends Message { + /** + * @generated from field: exa.codeium_common_pb.DocumentQuery document_query = 1; + */ + documentQuery; + /** + * Ordered list of overlapped code context items including partial overlaps. + * + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem overlapped_code_context_items = 2; + */ + overlappedCodeContextItems = []; + /** + * How many lines of the first and last overlapped code context items overlap + * with the document query itself. + * + * @generated from field: uint32 first_element_suffix_overlap = 3; + */ + firstElementSuffixOverlap = 0; + /** + * @generated from field: uint32 last_element_prefix_overlap = 4; + */ + lastElementPrefixOverlap = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DocumentLinesElement'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'document_query', kind: 'message', T: DocumentQuery }, + { + no: 2, + name: 'overlapped_code_context_items', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + { + no: 3, + name: 'first_element_suffix_overlap', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'last_element_prefix_overlap', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _DocumentLinesElement().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DocumentLinesElement().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DocumentLinesElement().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DocumentLinesElement, a, b); + } +}; +var DocumentQuery = class _DocumentQuery extends Message { + /** + * @generated from field: string text = 1; + */ + text = ''; + /** + * @generated from field: int32 cursor_offset = 2; + */ + cursorOffset = 0; + /** + * @generated from field: uint32 start_line = 3; + */ + startLine = 0; + /** + * End exclusive + * + * @generated from field: uint32 end_line = 4; + */ + endLine = 0; + /** + * @generated from field: bool use_character_position = 5; + */ + useCharacterPosition = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DocumentQuery'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'cursor_offset', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'start_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'end_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'use_character_position', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _DocumentQuery().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DocumentQuery().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DocumentQuery().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DocumentQuery, a, b); + } +}; +var DocumentOutlineElement = class _DocumentOutlineElement extends Message { + /** + * @generated from oneof exa.codeium_common_pb.DocumentOutlineElement.element + */ + element = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DocumentOutlineElement'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'code_context_item', + kind: 'message', + T: CodeContextItem, + oneof: 'element', + }, + { + no: 2, + name: 'document_lines_element', + kind: 'message', + T: DocumentLinesElement, + oneof: 'element', + }, + { no: 3, name: 'text', kind: 'scalar', T: 9, oneof: 'element' }, + ]); + static fromBinary(bytes, options) { + return new _DocumentOutlineElement().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DocumentOutlineElement().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DocumentOutlineElement().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DocumentOutlineElement, a, b); + } +}; +var DocumentOutline = class _DocumentOutline extends Message { + /** + * The document outline consists of an ordered list of elements in top to + * bottom order. + * + * @generated from field: repeated exa.codeium_common_pb.DocumentOutlineElement elements = 1; + */ + elements = []; + /** + * When building a prompt out of the outline with a token limit, we start at + * this element and radiate outward until hitting a token limit. If unset, + * then it will just build from top down. + * + * @generated from field: int64 start_index = 2; + */ + startIndex = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DocumentOutline'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'elements', + kind: 'message', + T: DocumentOutlineElement, + repeated: true, + }, + { + no: 2, + name: 'start_index', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _DocumentOutline().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DocumentOutline().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DocumentOutline().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DocumentOutline, a, b); + } +}; +var ProductEvent = class _ProductEvent extends Message { + /** + * @generated from field: string event_name = 1; + */ + eventName = ''; + /** + * @generated from field: string api_key = 2; + */ + apiKey = ''; + /** + * @generated from field: string installation_id = 3; + */ + installationId = ''; + /** + * @generated from field: string ide_name = 4; + */ + ideName = ''; + /** + * @generated from field: string os = 5; + */ + os = ''; + /** + * @generated from field: string codeium_version = 6; + */ + codeiumVersion = ''; + /** + * @generated from field: string ide_version = 7; + */ + ideVersion = ''; + /** + * @generated from field: uint64 duration_ms = 8; + */ + durationMs = protoInt64.zero; + /** + * @generated from field: map extra = 9; + */ + extra = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ProductEvent'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'event_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'api_key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'installation_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'ide_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'os', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'codeium_version', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'ide_version', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'duration_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 9, + name: 'extra', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _ProductEvent().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ProductEvent().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ProductEvent().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ProductEvent, a, b); + } +}; +var KnowledgeBaseChunk = class _KnowledgeBaseChunk extends Message { + /** + * @generated from oneof exa.codeium_common_pb.KnowledgeBaseChunk.chunk_type + */ + chunkType = { case: void 0 }; + /** + * @generated from field: int32 position = 2; + */ + position = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.KnowledgeBaseChunk'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'text', kind: 'scalar', T: 9, oneof: 'chunk_type' }, + { + no: 3, + name: 'markdown_chunk', + kind: 'message', + T: MarkdownChunk, + oneof: 'chunk_type', + }, + { + no: 2, + name: 'position', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeBaseChunk().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeBaseChunk().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeBaseChunk().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeBaseChunk, a, b); + } +}; +var KnowledgeBaseItem = class _KnowledgeBaseItem extends Message { + /** + * @generated from field: string document_id = 1; + */ + documentId = ''; + /** + * @generated from field: string url = 3; + */ + url = ''; + /** + * @generated from field: string title = 4; + */ + title = ''; + /** + * @generated from field: google.protobuf.Timestamp timestamp = 5; + */ + timestamp; + /** + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseChunk chunks = 6; + */ + chunks = []; + /** + * Optional summary of the knowledge base item. + * + * @generated from field: string summary = 7; + */ + summary = ''; + /** + * Optional DOM tree of the knowledge base item. + * + * @generated from field: exa.codeium_common_pb.DOMTree dom_tree = 9; + */ + domTree; + /** + * Deprecated: Use media instead + * + * @generated from field: exa.codeium_common_pb.ImageData image = 8 [deprecated = true]; + * @deprecated + */ + image; + /** + * Optional media data of the knowledge base item. + * + * @generated from field: exa.codeium_common_pb.Media media = 10; + */ + media; + /** + * Deprecated + * + * @generated from field: string text = 2 [deprecated = true]; + * @deprecated + */ + text = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.KnowledgeBaseItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'document_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'timestamp', kind: 'message', T: Timestamp }, + { + no: 6, + name: 'chunks', + kind: 'message', + T: KnowledgeBaseChunk, + repeated: true, + }, + { + no: 7, + name: 'summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 9, name: 'dom_tree', kind: 'message', T: DOMTree }, + { no: 8, name: 'image', kind: 'message', T: ImageData }, + { no: 10, name: 'media', kind: 'message', T: Media }, + { + no: 2, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeBaseItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeBaseItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeBaseItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeBaseItem, a, b); + } +}; +var KnowledgeBaseItemWithMetadata = class _KnowledgeBaseItemWithMetadata extends Message { + /** + * @generated from field: exa.codeium_common_pb.KnowledgeBaseItem knowledge_base_item = 1; + */ + knowledgeBaseItem; + /** + * not being used at the moment + * + * @generated from field: float score = 2; + */ + score = 0; + /** + * TODO(sean) / TODO(saujasn): remove index_name field + * + * always going to be "knowledge_base" for beacon + * + * @generated from field: string index_name = 3; + */ + indexName = ''; + /** + * where the document came from, + * + * @generated from field: string document_source_name = 4; + */ + documentSourceName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.KnowledgeBaseItemWithMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'knowledge_base_item', + kind: 'message', + T: KnowledgeBaseItem, + }, + { + no: 2, + name: 'score', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 3, + name: 'index_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'document_source_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeBaseItemWithMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeBaseItemWithMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeBaseItemWithMetadata().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeBaseItemWithMetadata, a, b); + } +}; +var KnowledgeBaseGroup = class _KnowledgeBaseGroup extends Message { + /** + * @generated from field: string description = 1; + */ + description = ''; + /** + * not required for aggregates, i.e. Slack channels + * + * @generated from field: exa.codeium_common_pb.KnowledgeBaseItemWithMetadata item = 2; + */ + item; + /** + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseGroup children = 3; + */ + children = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.KnowledgeBaseGroup'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'item', kind: 'message', T: KnowledgeBaseItemWithMetadata }, + { + no: 3, + name: 'children', + kind: 'message', + T: _KnowledgeBaseGroup, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeBaseGroup().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeBaseGroup().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeBaseGroup().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeBaseGroup, a, b); + } +}; +var ImageData = class _ImageData extends Message { + /** + * Base64 encoded image data + * + * @generated from field: string base64_data = 1; + */ + base64Data = ''; + /** + * MIME type of the image (e.g., "image/jpeg", "image/png") + * + * @generated from field: string mime_type = 2; + */ + mimeType = ''; + /** + * AI Generated Caption, populated when using a model that has + * supportsImageCaptions = true + * + * @generated from field: string caption = 3; + */ + caption = ''; + /** + * Optional URI where the image is stored (e.g., file path or URL) + * + * @generated from field: string uri = 4; + */ + uri = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ImageData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'base64_data', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'mime_type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'caption', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ImageData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ImageData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ImageData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ImageData, a, b); + } +}; +var Blobref = class _Blobref extends Message { + /** + * @generated from field: string blob_id = 1; + */ + blobId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Blobref'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'blob_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _Blobref().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Blobref().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Blobref().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Blobref, a, b); + } +}; +var Media = class _Media extends Message { + /** + * MIME type of the media, e.g., "text/plain", "image/jpeg", etc. + * + * @generated from field: string mime_type = 1; + */ + mimeType = ''; + /** + * Optional description of the media, e.g., "Screenshot of the app" + * Or summary of the media + * + * @generated from field: string description = 4; + */ + description = ''; + /** + * @generated from oneof exa.codeium_common_pb.Media.payload + */ + payload = { case: void 0 }; + /** + * Optional URI where the media is stored (e.g., file path or URL) + * + * @generated from field: string uri = 5; + */ + uri = ''; + /** + * Optional thumbnail for video + * + * @generated from field: bytes thumbnail = 6; + */ + thumbnail = new Uint8Array(0); + /** + * Optional duration in seconds for video + * + * @generated from field: float duration_seconds = 7; + */ + durationSeconds = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Media'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'mime_type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'inline_data', kind: 'scalar', T: 12, oneof: 'payload' }, + { no: 3, name: 'blobref', kind: 'message', T: Blobref, oneof: 'payload' }, + { + no: 5, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'thumbnail', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + { + no: 7, + name: 'duration_seconds', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + ]); + static fromBinary(bytes, options) { + return new _Media().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Media().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Media().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Media, a, b); + } +}; +var TextData = class _TextData extends Message { + /** + * @generated from field: string text = 1; + */ + text = ''; + /** + * MIME type of the text (e.g., "text/plain", "text/markdown") + * + * @generated from field: string mime_type = 2; + */ + mimeType = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TextData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'mime_type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _TextData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TextData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TextData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TextData, a, b); + } +}; +var MarkdownChunk = class _MarkdownChunk extends Message { + /** + * An array of headers that the text belongs to. The last element of the array + * is the most recent header that the text belongs to. + * + * @generated from field: repeated exa.codeium_common_pb.MarkdownChunk.MarkdownHeader headers = 1; + */ + headers = []; + /** + * The text in the markdown chunk. + * + * @generated from field: string text = 2; + */ + text = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.MarkdownChunk'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'headers', + kind: 'message', + T: MarkdownChunk_MarkdownHeader, + repeated: true, + }, + { + no: 2, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _MarkdownChunk().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MarkdownChunk().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MarkdownChunk().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_MarkdownChunk, a, b); + } +}; +var MarkdownChunk_MarkdownHeader = class _MarkdownChunk_MarkdownHeader extends Message { + /** + * @generated from field: exa.codeium_common_pb.MarkdownNodeType type = 1; + */ + type = MarkdownNodeType.UNSPECIFIED; + /** + * @generated from field: string text = 2; + */ + text = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.MarkdownChunk.MarkdownHeader'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(MarkdownNodeType), + }, + { + no: 2, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _MarkdownChunk_MarkdownHeader().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MarkdownChunk_MarkdownHeader().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MarkdownChunk_MarkdownHeader().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_MarkdownChunk_MarkdownHeader, a, b); + } +}; +var TerminalShellCommandHeader = class _TerminalShellCommandHeader extends Message { + /** + * @generated from field: exa.codeium_common_pb.Metadata metadata = 7; + */ + metadata; + /** + * ID of the terminal that the command was executed in. + * + * @generated from field: string terminal_id = 1; + */ + terminalId = ''; + /** + * PID of the shell process that executed the command. + * + * @generated from field: uint32 shell_pid = 2; + */ + shellPid = 0; + /** + * Shell command line that was executed. Note that this combines the command + * and the arguments. + * + * @generated from field: string command_line = 3; + */ + commandLine = ''; + /** + * Working directory that the shell command was executed in. + * + * @generated from field: string cwd = 4; + */ + cwd = ''; + /** + * Timestamp when the shell command was executed. + * + * @generated from field: google.protobuf.Timestamp start_time = 5; + */ + startTime; + /** + * Source of the shell command. + * + * @generated from field: exa.codeium_common_pb.TerminalShellCommandSource source = 6; + */ + source = TerminalShellCommandSource.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TerminalShellCommandHeader'; + static fields = proto3.util.newFieldList(() => [ + { no: 7, name: 'metadata', kind: 'message', T: Metadata }, + { + no: 1, + name: 'terminal_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'shell_pid', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'command_line', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'cwd', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'start_time', kind: 'message', T: Timestamp }, + { + no: 6, + name: 'source', + kind: 'enum', + T: proto3.getEnumType(TerminalShellCommandSource), + }, + ]); + static fromBinary(bytes, options) { + return new _TerminalShellCommandHeader().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TerminalShellCommandHeader().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TerminalShellCommandHeader().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_TerminalShellCommandHeader, a, b); + } +}; +var TerminalShellCommandData = class _TerminalShellCommandData extends Message { + /** + * New raw data bytes (delta) from the command output. + * + * @generated from field: bytes raw_data = 1; + */ + rawData = new Uint8Array(0); + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TerminalShellCommandData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'raw_data', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + ]); + static fromBinary(bytes, options) { + return new _TerminalShellCommandData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TerminalShellCommandData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TerminalShellCommandData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TerminalShellCommandData, a, b); + } +}; +var TerminalShellCommandTrailer = class _TerminalShellCommandTrailer extends Message { + /** + * Exit code of the command. Will be unset if the exit code cannot be + * determined. + * + * @generated from field: optional int32 exit_code = 1; + */ + exitCode; + /** + * Timestamp when the shell command finished executing. + * + * @generated from field: google.protobuf.Timestamp end_time = 2; + */ + endTime; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TerminalShellCommandTrailer'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'exit_code', kind: 'scalar', T: 5, opt: true }, + { no: 2, name: 'end_time', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _TerminalShellCommandTrailer().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TerminalShellCommandTrailer().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TerminalShellCommandTrailer().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_TerminalShellCommandTrailer, a, b); + } +}; +var TerminalShellCommandStreamChunk = class _TerminalShellCommandStreamChunk extends Message { + /** + * @generated from oneof exa.codeium_common_pb.TerminalShellCommandStreamChunk.value + */ + value = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TerminalShellCommandStreamChunk'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'header', + kind: 'message', + T: TerminalShellCommandHeader, + oneof: 'value', + }, + { + no: 2, + name: 'data', + kind: 'message', + T: TerminalShellCommandData, + oneof: 'value', + }, + { + no: 3, + name: 'trailer', + kind: 'message', + T: TerminalShellCommandTrailer, + oneof: 'value', + }, + ]); + static fromBinary(bytes, options) { + return new _TerminalShellCommandStreamChunk().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TerminalShellCommandStreamChunk().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TerminalShellCommandStreamChunk().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_TerminalShellCommandStreamChunk, a, b); + } +}; +var TerminalShellCommand = class _TerminalShellCommand extends Message { + /** + * Unique ID for the shell command. + * + * @generated from field: string id = 10; + */ + id = ''; + /** + * PID of the shell process that executed the command. + * + * @generated from field: uint32 shell_pid = 1; + */ + shellPid = 0; + /** + * Shell command line that was executed. Note that this combines the command + * and the arguments. + * + * @generated from field: string command_line = 2; + */ + commandLine = ''; + /** + * Working directory that the shell command was executed in. + * + * @generated from field: string cwd = 3; + */ + cwd = ''; + /** + * Aggregated and processed output. + * + * @generated from field: bytes output = 4; + */ + output = new Uint8Array(0); + /** + * Exit code of the command. Will be unset if the exit code cannot be + * determined. + * + * @generated from field: optional int32 exit_code = 5; + */ + exitCode; + /** + * Timestamp when the shell command was executed. + * + * @generated from field: google.protobuf.Timestamp start_time = 6; + */ + startTime; + /** + * Timestamp when the shell command finished executing. + * + * @generated from field: google.protobuf.Timestamp end_time = 7; + */ + endTime; + /** + * Timestamp when the shell command was last updated. + * + * @generated from field: google.protobuf.Timestamp last_updated_time = 11; + */ + lastUpdatedTime; + /** + * Status of the shell command. + * + * @generated from field: exa.codeium_common_pb.TerminalShellCommandStatus status = 8; + */ + status = TerminalShellCommandStatus.UNSPECIFIED; + /** + * Source of the shell command. + * + * @generated from field: exa.codeium_common_pb.TerminalShellCommandSource source = 9; + */ + source = TerminalShellCommandSource.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TerminalShellCommand'; + static fields = proto3.util.newFieldList(() => [ + { + no: 10, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 1, + name: 'shell_pid', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'command_line', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'cwd', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'output', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + { no: 5, name: 'exit_code', kind: 'scalar', T: 5, opt: true }, + { no: 6, name: 'start_time', kind: 'message', T: Timestamp }, + { no: 7, name: 'end_time', kind: 'message', T: Timestamp }, + { no: 11, name: 'last_updated_time', kind: 'message', T: Timestamp }, + { + no: 8, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(TerminalShellCommandStatus), + }, + { + no: 9, + name: 'source', + kind: 'enum', + T: proto3.getEnumType(TerminalShellCommandSource), + }, + ]); + static fromBinary(bytes, options) { + return new _TerminalShellCommand().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TerminalShellCommand().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TerminalShellCommand().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TerminalShellCommand, a, b); + } +}; +var TerminalCommandData = class _TerminalCommandData extends Message { + /** + * @generated from field: string terminal_id = 1; + */ + terminalId = ''; + /** + * @generated from field: string platform = 2; + */ + platform = ''; + /** + * @generated from field: string cwd = 3; + */ + cwd = ''; + /** + * @generated from field: string shell_name = 4; + */ + shellName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TerminalCommandData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'terminal_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'platform', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'cwd', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'shell_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _TerminalCommandData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TerminalCommandData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TerminalCommandData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TerminalCommandData, a, b); + } +}; +var AntigravityProject = class _AntigravityProject extends Message { + /** + * @generated from field: string antigravity_project_id = 1; + */ + antigravityProjectId = ''; + /** + * @generated from field: string auth_uid = 2; + */ + authUid = ''; + /** + * @generated from field: exa.codeium_common_pb.DeploymentProvider deployment_provider = 3; + */ + deploymentProvider = DeploymentProvider.UNSPECIFIED; + /** + * @generated from field: string provider_project_id = 4; + */ + providerProjectId = ''; + /** + * The name of the project. This shows up on the provider dashboard and is + * different from the subdomain name. + * + * @generated from field: string project_name = 5; + */ + projectName = ''; + /** + * @generated from field: google.protobuf.Timestamp created_at = 6; + */ + createdAt; + /** + * @generated from field: google.protobuf.Timestamp updated_at = 7; + */ + updatedAt; + /** + * The domain the deployment is deployed to. Example: antigravity.build + * + * @generated from field: string domain = 8; + */ + domain = ''; + /** + * The subdomain the deployment is deployed to. Example: my-project + * + * @generated from field: string subdomain_name = 9; + */ + subdomainName = ''; + /** + * When the deployment will expire (after which it will be removed by the cron + * job) + * + * @generated from field: google.protobuf.Timestamp expires_at = 10; + */ + expiresAt; + /** + * When the deployment was claimed by the user. If site is unclaimed, this + * will be unset. + * + * @generated from field: google.protobuf.Timestamp claimed_at = 11; + */ + claimedAt; + /** + * When the deployment was removed from the domain to free up the site name. + * This is done after the site expires by the cron job. + * + * @generated from field: google.protobuf.Timestamp deprovisioned_at = 12; + */ + deprovisionedAt; + /** + * Team ID of the provider if this project is not on the Antigravity sandbox + * account + * + * @generated from field: string provider_team_id = 14; + */ + providerTeamId = ''; + /** + * Public URL to access the app + * + * @generated from field: string project_url = 13; + */ + projectUrl = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.AntigravityProject'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'antigravity_project_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'auth_uid', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'deployment_provider', + kind: 'enum', + T: proto3.getEnumType(DeploymentProvider), + }, + { + no: 4, + name: 'provider_project_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'project_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 6, name: 'created_at', kind: 'message', T: Timestamp }, + { no: 7, name: 'updated_at', kind: 'message', T: Timestamp }, + { + no: 8, + name: 'domain', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'subdomain_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 10, name: 'expires_at', kind: 'message', T: Timestamp }, + { no: 11, name: 'claimed_at', kind: 'message', T: Timestamp }, + { no: 12, name: 'deprovisioned_at', kind: 'message', T: Timestamp }, + { + no: 14, + name: 'provider_team_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 13, + name: 'project_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _AntigravityProject().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AntigravityProject().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AntigravityProject().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AntigravityProject, a, b); + } +}; +var AntigravityDeployment = class _AntigravityDeployment extends Message { + /** + * @generated from field: string antigravity_deployment_id = 1; + */ + antigravityDeploymentId = ''; + /** + * @generated from field: string auth_uid = 2; + */ + authUid = ''; + /** + * @generated from field: exa.codeium_common_pb.DeploymentProvider deployment_provider = 3; + */ + deploymentProvider = DeploymentProvider.UNSPECIFIED; + /** + * @generated from field: string provider_deployment_id = 14; + */ + providerDeploymentId = ''; + /** + * This references the antigravity_project_id + * + * @generated from field: string antigravity_project_id = 19; + */ + antigravityProjectId = ''; + /** + * in the antigravity_projects table + * + * @generated from field: string project_id = 4; + */ + projectId = ''; + /** + * @generated from field: string project_name = 5; + */ + projectName = ''; + /** + * @generated from field: string workspace_path = 6; + */ + workspacePath = ''; + /** + * @generated from field: google.protobuf.Timestamp created_at = 7; + */ + createdAt; + /** + * @generated from field: google.protobuf.Timestamp updated_at = 8; + */ + updatedAt; + /** + * The domain the deployment is deployed to. Example: antigravity.build + * + * @generated from field: string domain = 16; + */ + domain = ''; + /** + * The subdomain the deployment is deployed to. Example: my-project + * + * @generated from field: string subdomain_name = 17; + */ + subdomainName = ''; + /** + * Team ID of the provider if this project is not on the Antigravity sandbox + * account + * + * @generated from field: string provider_team_id = 20; + */ + providerTeamId = ''; + /** + * When the deployment will expire (after which it will be removed by the cron + * job) + * + * @generated from field: google.protobuf.Timestamp expires_at = 11; + */ + expiresAt; + /** + * URL to access this specific deployment. This is different from the + * .antigravity.app URL (which is the public URL). + * + * @generated from field: string deployment_url = 12; + */ + deploymentUrl = ''; + /** + * When the deployment was claimed by the user. If site is unclaimed, this + * will be unset. + * + * @generated from field: google.protobuf.Timestamp claimed_at = 15; + */ + claimedAt; + /** + * When the deployment was removed from the domain to free up the site name. + * This is done after the site expires by the cron job. + * + * @generated from field: google.protobuf.Timestamp deprovisioned_at = 13; + */ + deprovisionedAt; + /** + * URL to the build status page on the Codeium website + * + * @generated from field: string build_status_url = 9; + */ + buildStatusUrl = ''; + /** + * Public URL to access the app + * + * @generated from field: string project_url = 10; + */ + projectUrl = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.AntigravityDeployment'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'antigravity_deployment_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'auth_uid', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'deployment_provider', + kind: 'enum', + T: proto3.getEnumType(DeploymentProvider), + }, + { + no: 14, + name: 'provider_deployment_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 19, + name: 'antigravity_project_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'project_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'project_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'workspace_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 7, name: 'created_at', kind: 'message', T: Timestamp }, + { no: 8, name: 'updated_at', kind: 'message', T: Timestamp }, + { + no: 16, + name: 'domain', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 17, + name: 'subdomain_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 20, + name: 'provider_team_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 11, name: 'expires_at', kind: 'message', T: Timestamp }, + { + no: 12, + name: 'deployment_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 15, name: 'claimed_at', kind: 'message', T: Timestamp }, + { no: 13, name: 'deprovisioned_at', kind: 'message', T: Timestamp }, + { + no: 9, + name: 'build_status_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'project_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _AntigravityDeployment().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AntigravityDeployment().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AntigravityDeployment().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AntigravityDeployment, a, b); + } +}; +var DeployTarget = class _DeployTarget extends Message { + /** + * Deployment provider (i.e. Netlify) + * + * @generated from field: exa.codeium_common_pb.DeploymentProvider deployment_provider = 1; + */ + deploymentProvider = DeploymentProvider.UNSPECIFIED; + /** + * Whether the site is on the Antigravity umbrella account + * + * @generated from field: bool is_sandbox = 2; + */ + isSandbox = false; + /** + * ID of the team that owns the site. Unset if the site is on the umbrella + * account + * + * @generated from field: string provider_team_id = 3; + */ + providerTeamId = ''; + /** + * Slug of the team that owns the site. This is "antigravity" if the site is + * on the umbrella account + * + * @generated from field: string provider_team_slug = 4; + */ + providerTeamSlug = ''; + /** + * Domain of the site + * + * @generated from field: string domain = 5; + */ + domain = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DeployTarget'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'deployment_provider', + kind: 'enum', + T: proto3.getEnumType(DeploymentProvider), + }, + { + no: 2, + name: 'is_sandbox', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'provider_team_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'provider_team_slug', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'domain', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _DeployTarget().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DeployTarget().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DeployTarget().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DeployTarget, a, b); + } +}; +var WebDocsOption = class _WebDocsOption extends Message { + /** + * The label of the option. This must not contain any spaces. This is what + * will be rendered in `[@docs:label](docs_url)`. Allowed characters: a-z, + * A-Z, 0-9, _, -. + * + * @generated from field: string label = 1; + */ + label = ''; + /** + * The URL of the documentation or human-language instructions to prompt the + * LLM to lookup live documentation via web search. + * + * @generated from oneof exa.codeium_common_pb.WebDocsOption.value + */ + value = { case: void 0 }; + /** + * A space-separated list of synonyms for the option. This is used for + * searching through options if the user does not enter a match to the + * `label`. + * + * @generated from field: repeated string synonyms = 4; + */ + synonyms = []; + /** + * Whether this is a featured docs provider. + * + * @generated from field: bool is_featured = 5; + */ + isFeatured = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.WebDocsOption'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'label', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'docs_url', kind: 'scalar', T: 9, oneof: 'value' }, + { no: 3, name: 'docs_search_domain', kind: 'scalar', T: 9, oneof: 'value' }, + { no: 4, name: 'synonyms', kind: 'scalar', T: 9, repeated: true }, + { + no: 5, + name: 'is_featured', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _WebDocsOption().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WebDocsOption().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WebDocsOption().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_WebDocsOption, a, b); + } +}; +var TeamConfig = class _TeamConfig extends Message { + /** + * @generated from field: string team_id = 1; + */ + teamId = ''; + /** + * @generated from field: int32 user_prompt_credit_cap = 2; + */ + userPromptCreditCap = 0; + /** + * @generated from field: int32 user_flow_credit_cap = 3; + */ + userFlowCreditCap = 0; + /** + * @generated from field: bool auto_provision_cascade_seat = 4; + */ + autoProvisionCascadeSeat = false; + /** + * @generated from field: bool allow_mcp_servers = 5; + */ + allowMcpServers = false; + /** + * TODO(michaelli): Move web search from teams table to team config. + * bool allow_web_search = 6; + * + * @generated from field: bool allow_auto_run_commands = 7; + */ + allowAutoRunCommands = false; + /** + * Maximum number of unclaimed sites for Antigravity deployments a user can + * have. + * Moved from PlanInfo to TeamConfig. This is disconnected from + * allow_app_deployments and can be > 0 even if allow_app_deployments is + * false. + * + * @generated from field: int32 max_unclaimed_sites = 9; + */ + maxUnclaimedSites = 0; + /** + * Whether app deployments are allowed for this team. + * + * @generated from field: bool allow_app_deployments = 10; + */ + allowAppDeployments = false; + /** + * Whether deployment to the shared sandbox/umbrella account is allowed. + * + * @generated from field: bool allow_sandbox_app_deployments = 19; + */ + allowSandboxAppDeployments = false; + /** + * Whether deployment directly to user-connected team accounts is allowed. + * + * @generated from field: bool allow_teams_app_deployments = 20; + */ + allowTeamsAppDeployments = false; + /** + * Maximum number of new sites a user can create per day. This limits the rate + * at which users can create new domains. The client should use + * max_unclaimed_sites and allow_app_deployments to determine if the Deploys + * feature is enabled. + * + * @generated from field: int32 max_new_sites_per_day = 11; + */ + maxNewSitesPerDay = 0; + /** + * Whether Antigravity is allowed to create pull request reviews on GitHub for + * this team. + * + * @generated from field: bool allow_github_reviews = 12; + */ + allowGithubReviews = false; + /** + * Whether Antigravity is allowed to edit pull request descriptions on GitHub + * for this team. + * + * @generated from field: bool allow_github_description_edits = 13; + */ + allowGithubDescriptionEdits = false; + /** + * Guidelines that Antigravity will use when reviewing pull requests. + * + * @generated from field: string pull_request_review_guidelines = 14; + */ + pullRequestReviewGuidelines = ''; + /** + * Guidelines that Antigravity will use when editing pull request + * descriptions. + * + * @generated from field: string pull_request_description_guidelines = 16; + */ + pullRequestDescriptionGuidelines = ''; + /** + * Whether tool calls are disabled for this team. + * + * @generated from field: bool disable_tool_calls = 15; + */ + disableToolCalls = false; + /** + * Whether individual level analytics are allowed for this team. + * + * @generated from field: bool allow_individual_level_analytics = 17; + */ + allowIndividualLevelAnalytics = false; + /** + * Whether conversation sharing is allowed for this team. + * Note that this is an optional because we need to treat the 'not set' + * case differently based on the user's team tier. For example, SAAS teams + * will have this enabled by default, while enterprise teams will have it + * disabled. + * + * @generated from field: optional bool allow_conversation_sharing = 18; + */ + allowConversationSharing; + /** + * Rate limit for number of pull request reviews per month + * Currently used only for boosting a team's quota on case-by-case basis. + * When it's not set, we use the default `DefaultMaxRequestsPerTimeWindow`. + * + * @generated from field: optional int32 pull_request_review_rate_limit = 21; + */ + pullRequestReviewRateLimit; + /** + * Whether attribution is allowed for this team. + * + * @generated from field: bool allow_attribution = 22; + */ + allowAttribution = false; + /** + * MCP servers that are allowed for this team. + * + * @generated from field: repeated exa.codeium_common_pb.McpServerConfig allowed_mcp_servers = 23; + */ + allowedMcpServers = []; + /** + * Whether auto reviews are allowed for this team. + * + * @generated from field: bool allow_github_auto_reviews = 24; + */ + allowGithubAutoReviews = false; + /** + * Whether browser experimental features are allowed for this team. + * + * @generated from field: bool allow_browser_experimental_features = 25; + */ + allowBrowserExperimentalFeatures = false; + /** + * Whether tool call execution outside of the workspace is disabled for this + * team. + * + * @generated from field: bool disable_tool_call_execution_outside_workspace = 26; + */ + disableToolCallExecutionOutsideWorkspace = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TeamConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'team_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'user_prompt_credit_cap', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'user_flow_credit_cap', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'auto_provision_cascade_seat', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'allow_mcp_servers', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'allow_auto_run_commands', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 9, + name: 'max_unclaimed_sites', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 10, + name: 'allow_app_deployments', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 19, + name: 'allow_sandbox_app_deployments', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 20, + name: 'allow_teams_app_deployments', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 11, + name: 'max_new_sites_per_day', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 12, + name: 'allow_github_reviews', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 13, + name: 'allow_github_description_edits', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 14, + name: 'pull_request_review_guidelines', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 16, + name: 'pull_request_description_guidelines', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 15, + name: 'disable_tool_calls', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 17, + name: 'allow_individual_level_analytics', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 18, + name: 'allow_conversation_sharing', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 21, + name: 'pull_request_review_rate_limit', + kind: 'scalar', + T: 5, + opt: true, + }, + { + no: 22, + name: 'allow_attribution', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 23, + name: 'allowed_mcp_servers', + kind: 'message', + T: McpServerConfig, + repeated: true, + }, + { + no: 24, + name: 'allow_github_auto_reviews', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 25, + name: 'allow_browser_experimental_features', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 26, + name: 'disable_tool_call_execution_outside_workspace', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _TeamConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TeamConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TeamConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TeamConfig, a, b); + } +}; +var WebAppDeploymentConfig = class _WebAppDeploymentConfig extends Message { + /** + * The ID of the project (different from project name) on the provider's + * system. This is populated as a way to update existing deployments. + * + * @generated from field: string project_id = 1; + */ + projectId = ''; + /** + * The framework used for the app (examples: nextjs, sveltekit, etc.). + * + * @generated from field: string framework = 2; + */ + framework = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.WebAppDeploymentConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'project_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'framework', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _WebAppDeploymentConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WebAppDeploymentConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WebAppDeploymentConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_WebAppDeploymentConfig, a, b); + } +}; +var McpServerTemplate = class _McpServerTemplate extends Message { + /** + * @generated from field: string title = 1; + */ + title = ''; + /** + * @generated from field: string id = 2; + */ + id = ''; + /** + * @generated from field: string link = 3; + */ + link = ''; + /** + * @generated from field: string description = 4; + */ + description = ''; + /** + * Key is the command type (e.g., "npx", "docker") + * + * @generated from field: map commands = 5; + */ + commands = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.McpServerTemplate'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'link', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'commands', + kind: 'map', + K: 9, + V: { kind: 'message', T: McpServerCommand }, + }, + ]); + static fromBinary(bytes, options) { + return new _McpServerTemplate().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpServerTemplate().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpServerTemplate().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpServerTemplate, a, b); + } +}; +var McpServerCommand = class _McpServerCommand extends Message { + /** + * @generated from field: exa.codeium_common_pb.McpCommandTemplate template = 1; + */ + template; + /** + * @generated from field: repeated exa.codeium_common_pb.McpCommandVariable variables = 2; + */ + variables = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.McpServerCommand'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'template', kind: 'message', T: McpCommandTemplate }, + { + no: 2, + name: 'variables', + kind: 'message', + T: McpCommandVariable, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _McpServerCommand().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpServerCommand().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpServerCommand().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpServerCommand, a, b); + } +}; +var McpCommandTemplate = class _McpCommandTemplate extends Message { + /** + * @generated from field: string command = 1; + */ + command = ''; + /** + * @generated from field: repeated string args = 2; + */ + args = []; + /** + * @generated from field: map env = 3; + */ + env = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.McpCommandTemplate'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'command', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'args', kind: 'scalar', T: 9, repeated: true }, + { + no: 3, + name: 'env', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _McpCommandTemplate().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpCommandTemplate().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpCommandTemplate().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpCommandTemplate, a, b); + } +}; +var McpCommandVariable = class _McpCommandVariable extends Message { + /** + * @generated from field: string name = 1; + */ + name = ''; + /** + * @generated from field: string title = 2; + */ + title = ''; + /** + * @generated from field: string description = 3; + */ + description = ''; + /** + * @generated from field: string link = 4; + */ + link = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.McpCommandVariable'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'link', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _McpCommandVariable().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpCommandVariable().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpCommandVariable().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpCommandVariable, a, b); + } +}; +var McpServerConfig = class _McpServerConfig extends Message { + /** + * @generated from field: string server_id = 1; + */ + serverId = ''; + /** + * @generated from oneof exa.codeium_common_pb.McpServerConfig.configuration + */ + configuration = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.McpServerConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'server_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'local', + kind: 'message', + T: McpLocalServer, + oneof: 'configuration', + }, + { + no: 3, + name: 'remote', + kind: 'message', + T: McpRemoteServer, + oneof: 'configuration', + }, + ]); + static fromBinary(bytes, options) { + return new _McpServerConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpServerConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpServerConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpServerConfig, a, b); + } +}; +var McpLocalServer = class _McpLocalServer extends Message { + /** + * @generated from field: string command = 1; + */ + command = ''; + /** + * @generated from field: repeated string args = 2; + */ + args = []; + /** + * @generated from field: map env = 3; + */ + env = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.McpLocalServer'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'command', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'args', kind: 'scalar', T: 9, repeated: true }, + { + no: 3, + name: 'env', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _McpLocalServer().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpLocalServer().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpLocalServer().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpLocalServer, a, b); + } +}; +var McpRemoteServer = class _McpRemoteServer extends Message { + /** + * @generated from field: string type = 1; + */ + type = ''; + /** + * @generated from field: string url = 2; + */ + url = ''; + /** + * @generated from field: map headers = 3; + */ + headers = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.McpRemoteServer'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'headers', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _McpRemoteServer().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpRemoteServer().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpRemoteServer().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpRemoteServer, a, b); + } +}; +var UnleashContext = class _UnleashContext extends Message { + /** + * @generated from field: string user_id = 1; + */ + userId = ''; + /** + * @generated from field: string session_id = 2; + */ + sessionId = ''; + /** + * @generated from field: map properties = 3; + */ + properties = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.UnleashContext'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'user_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'session_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'properties', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _UnleashContext().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UnleashContext().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UnleashContext().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UnleashContext, a, b); + } +}; +var BrowserStateSnapshot = class _BrowserStateSnapshot extends Message { + /** + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp; + /** + * @generated from field: string user_active_page_id = 2; + */ + userActivePageId = ''; + /** + * @generated from field: repeated exa.codeium_common_pb.BrowserPageMetadata pages = 3; + */ + pages = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.BrowserStateSnapshot'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'timestamp', kind: 'message', T: Timestamp }, + { + no: 2, + name: 'user_active_page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'pages', + kind: 'message', + T: BrowserPageMetadata, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserStateSnapshot().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserStateSnapshot().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserStateSnapshot().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserStateSnapshot, a, b); + } +}; +var BrowserPageMetadata = class _BrowserPageMetadata extends Message { + /** + * URL of the page. + * + * @generated from field: string url = 1; + */ + url = ''; + /** + * Playwright page identifier. + * + * @generated from field: string page_id = 2; + */ + pageId = ''; + /** + * Title of the page. + * + * @generated from field: string page_title = 3; + */ + pageTitle = ''; + /** + * Width of the viewport in pixels. + * + * @generated from field: uint32 viewport_width = 4; + */ + viewportWidth = 0; + /** + * Height of the viewport in pixels. + * + * @generated from field: uint32 viewport_height = 5; + */ + viewportHeight = 0; + /** + * Total scrollable document height in pixels. + * + * @generated from field: uint32 page_height = 9; + */ + pageHeight = 0; + /** + * URL of the favicon, if available. + * + * @generated from field: string favicon_url = 6; + */ + faviconUrl = ''; + /** + * Device pixel ratio of the page. + * + * @generated from field: float device_pixel_ratio = 8; + */ + devicePixelRatio = 0; + /** + * Time the page was last visited. + * + * @generated from field: google.protobuf.Timestamp last_visited_time = 7; + */ + lastVisitedTime; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.BrowserPageMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'page_title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'viewport_width', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'viewport_height', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 9, + name: 'page_height', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 6, + name: 'favicon_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'device_pixel_ratio', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { no: 7, name: 'last_visited_time', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _BrowserPageMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserPageMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserPageMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserPageMetadata, a, b); + } +}; +var BrowserClickInteraction = class _BrowserClickInteraction extends Message { + /** + * Viewport metadata at the time of the click. + * + * Horizontal scroll position of the viewport. + * + * @generated from field: uint32 viewport_scroll_x = 1; + */ + viewportScrollX = 0; + /** + * Vertical scroll position of the viewport. + * + * @generated from field: uint32 viewport_scroll_y = 2; + */ + viewportScrollY = 0; + /** + * Click position relative to the viewport. + * + * X position of the click relative to the viewport. + * + * @generated from field: uint32 click_x = 3; + */ + clickX = 0; + /** + * Y position of the click relative to the viewport. + * + * @generated from field: uint32 click_y = 4; + */ + clickY = 0; + /** + * Target element that was clicked. + * + * @generated from field: string target_element_tag_name = 5; + */ + targetElementTagName = ''; + /** + * @generated from field: string target_element_x_path = 6; + */ + targetElementXPath = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.BrowserClickInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'viewport_scroll_x', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'viewport_scroll_y', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'click_x', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'click_y', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'target_element_tag_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'target_element_x_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserClickInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserClickInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserClickInteraction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserClickInteraction, a, b); + } +}; +var BrowserScrollInteraction = class _BrowserScrollInteraction extends Message { + /** + * Viewport metadata after the scroll. + * + * Horizontal scroll position of the viewport. + * + * @generated from field: uint32 viewport_scroll_x = 1; + */ + viewportScrollX = 0; + /** + * Vertical scroll position of the viewport. + * + * @generated from field: uint32 viewport_scroll_y = 2; + */ + viewportScrollY = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.BrowserScrollInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'viewport_scroll_x', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'viewport_scroll_y', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserScrollInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserScrollInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserScrollInteraction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserScrollInteraction, a, b); + } +}; +var BrowserInteraction = class _BrowserInteraction extends Message { + /** + * Timestamp of the interaction. + * + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp; + /** + * Metadata associated with the page at the time of the interaction. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 2; + */ + pageMetadata; + /** + * The interaction that occurred. + * + * @generated from oneof exa.codeium_common_pb.BrowserInteraction.interaction + */ + interaction = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.BrowserInteraction'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'timestamp', kind: 'message', T: Timestamp }, + { no: 2, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 3, + name: 'click', + kind: 'message', + T: BrowserClickInteraction, + oneof: 'interaction', + }, + { + no: 4, + name: 'scroll', + kind: 'message', + T: BrowserScrollInteraction, + oneof: 'interaction', + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserInteraction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserInteraction, a, b); + } +}; +var MetricsMetadata = class _MetricsMetadata extends Message { + /** + * Version should be incremented if the metadata or implementation of the + * metric changes. + * + * @generated from field: int32 version = 1; + */ + version = 0; + /** + * Human readable description on how to interpret this metric. + * + * @generated from field: string description = 2; + */ + description = ''; + /** + * In which direction is this metric considered better. Leave unspecified if + * no direction. + * + * @generated from field: exa.codeium_common_pb.BetterDirection better_direction = 3; + */ + betterDirection = BetterDirection.UNSPECIFIED; + /** + * If 1 should be interpreted as true and 0 as false. + * + * @generated from field: bool is_bool = 4; + */ + isBool = false; + /** + * For aggregation purposes, consider the absence of this metric as this + * default value. Nulls are ignored if not specified. + * + * @generated from field: optional float null_default_value = 5; + */ + nullDefaultValue; + /** + * The scope of this metric. + * + * @generated from field: exa.codeium_common_pb.MetricsScope scope = 6; + */ + scope = MetricsScope.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.MetricsMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'version', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'better_direction', + kind: 'enum', + T: proto3.getEnumType(BetterDirection), + }, + { + no: 4, + name: 'is_bool', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 5, name: 'null_default_value', kind: 'scalar', T: 2, opt: true }, + { no: 6, name: 'scope', kind: 'enum', T: proto3.getEnumType(MetricsScope) }, + ]); + static fromBinary(bytes, options) { + return new _MetricsMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MetricsMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MetricsMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_MetricsMetadata, a, b); + } +}; +var MetricsRecord = class _MetricsRecord extends Message { + /** + * Primary identifier of the metric. + * + * @generated from field: string name = 1; + */ + name = ''; + /** + * Metadata relating to the generation and definition of the metric. + * + * @generated from field: exa.codeium_common_pb.MetricsMetadata metadata = 9; + */ + metadata; + /** + * Main data payload of the metric. + * + * @generated from field: float value = 2; + */ + value = 0; + /** + * @generated from field: map details = 3; + */ + details = {}; + /** + * If non-empty, then will be considered an error. + * + * @generated from field: string error = 6; + */ + error = ''; + /** + * Trajectory id corresponding to the generator metadata producing this + * record. Used primarily for LLM judge-based metrics. Empty if not + * applicable. If populated assumed to be metadata index 0. + * + * @generated from field: string trajectory_id = 7; + */ + trajectoryId = ''; + /** + * If a lower value is considered better. + * + * @generated from field: bool lower_better = 4 [deprecated = true]; + * @deprecated + */ + lowerBetter = false; + /** + * If 1 should be interpreted as true and 0 as false. + * + * @generated from field: bool is_bool = 5 [deprecated = true]; + * @deprecated + */ + isBool = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.MetricsRecord'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 9, name: 'metadata', kind: 'message', T: MetricsMetadata }, + { + no: 2, + name: 'value', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 3, + name: 'details', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { + no: 6, + name: 'error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'trajectory_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'lower_better', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'is_bool', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _MetricsRecord().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MetricsRecord().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MetricsRecord().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_MetricsRecord, a, b); + } +}; +var StepLevelMetricsRecord = class _StepLevelMetricsRecord extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.MetricsRecord metrics = 1; + */ + metrics = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.StepLevelMetricsRecord'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'metrics', + kind: 'message', + T: MetricsRecord, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _StepLevelMetricsRecord().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StepLevelMetricsRecord().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StepLevelMetricsRecord().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_StepLevelMetricsRecord, a, b); + } +}; +var ModelNotification = class _ModelNotification extends Message { + /** + * @generated from field: exa.codeium_common_pb.Model model = 1; + */ + model = Model.UNSPECIFIED; + /** + * @generated from field: string message = 2; + */ + message = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ModelNotification'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'model', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 2, + name: 'message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ModelNotification().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelNotification().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ModelNotification().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ModelNotification, a, b); + } +}; +var ModelNotificationExperimentPayload = class _ModelNotificationExperimentPayload extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.ModelNotification model_notifications = 1; + */ + modelNotifications = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ModelNotificationExperimentPayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'model_notifications', + kind: 'message', + T: ModelNotification, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ModelNotificationExperimentPayload().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelNotificationExperimentPayload().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _ModelNotificationExperimentPayload().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ModelNotificationExperimentPayload, a, b); + } +}; +var LspReference = class _LspReference extends Message { + /** + * URI string of the file containing the reference + * + * @generated from field: string uri = 1; + */ + uri = ''; + /** + * Range in the file + * + * @generated from field: exa.codeium_common_pb.Range range = 2; + */ + range; + /** + * Optional snippet of surrounding text that contains the reference + * + * @generated from field: optional string snippet = 3; + */ + snippet; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.LspReference'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'range', kind: 'message', T: Range }, + { no: 3, name: 'snippet', kind: 'scalar', T: 9, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _LspReference().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LspReference().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LspReference().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LspReference, a, b); + } +}; +var CascadeModelHeaderWarningExperimentPayload = class _CascadeModelHeaderWarningExperimentPayload extends Message { + /** + * @generated from field: string text = 1; + */ + text = ''; + /** + * @generated from field: string tooltip_text = 2; + */ + tooltipText = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.codeium_common_pb.CascadeModelHeaderWarningExperimentPayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'tooltip_text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeModelHeaderWarningExperimentPayload().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeModelHeaderWarningExperimentPayload().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeModelHeaderWarningExperimentPayload().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals( + _CascadeModelHeaderWarningExperimentPayload, + a, + b, + ); + } +}; +var CodeAnnotation = class _CodeAnnotation extends Message { + /** + * @generated from field: string id = 1; + */ + id = ''; + /** + * @generated from field: string uri = 2; + */ + uri = ''; + /** + * @generated from field: uint32 line = 3; + */ + line = 0; + /** + * @generated from field: string content = 4; + */ + content = ''; + /** + * @generated from field: google.protobuf.Timestamp created_at = 5; + */ + createdAt; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CodeAnnotation'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'created_at', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _CodeAnnotation().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeAnnotation().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeAnnotation().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeAnnotation, a, b); + } +}; +var CodeAnnotationsState = class _CodeAnnotationsState extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.CodeAnnotation annotations = 1; + */ + annotations = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.CodeAnnotationsState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'annotations', + kind: 'message', + T: CodeAnnotation, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CodeAnnotationsState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeAnnotationsState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeAnnotationsState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeAnnotationsState, a, b); + } +}; +var TrajectoryDescription = class _TrajectoryDescription extends Message { + /** + * @generated from oneof exa.codeium_common_pb.TrajectoryDescription.description + */ + description = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TrajectoryDescription'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'cascade_conversation_title', + kind: 'scalar', + T: 9, + oneof: 'description', + }, + { + no: 2, + name: 'mainline_branch_name', + kind: 'scalar', + T: 9, + oneof: 'description', + }, + ]); + static fromBinary(bytes, options) { + return new _TrajectoryDescription().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TrajectoryDescription().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TrajectoryDescription().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TrajectoryDescription, a, b); + } +}; +var ThirdPartyWebSearchConfig = class _ThirdPartyWebSearchConfig extends Message { + /** + * @generated from field: exa.codeium_common_pb.ThirdPartyWebSearchProvider provider = 1; + */ + provider = ThirdPartyWebSearchProvider.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ThirdPartyWebSearchConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'provider', + kind: 'enum', + T: proto3.getEnumType(ThirdPartyWebSearchProvider), + }, + ]); + static fromBinary(bytes, options) { + return new _ThirdPartyWebSearchConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ThirdPartyWebSearchConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ThirdPartyWebSearchConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ThirdPartyWebSearchConfig, a, b); + } +}; +var GRPCStatus = class _GRPCStatus extends Message { + /** + * @generated from field: int32 code = 1; + */ + code = 0; + /** + * @generated from field: string message = 2; + */ + message = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.GRPCStatus'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'code', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _GRPCStatus().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GRPCStatus().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GRPCStatus().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GRPCStatus, a, b); + } +}; +var WorkingDirectoryInfo = class _WorkingDirectoryInfo extends Message { + /** + * @generated from field: string absolute_uri = 1; + */ + absoluteUri = ''; + /** + * @generated from field: string relative_path = 2; + */ + relativePath = ''; + /** + * @generated from field: exa.codeium_common_pb.WorkingDirectoryStatus status = 3; + */ + status = WorkingDirectoryStatus.UNSPECIFIED; + /** + * Only populated if error is status. + * + * @generated from field: string error = 4; + */ + error = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.WorkingDirectoryInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'relative_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(WorkingDirectoryStatus), + }, + { + no: 4, + name: 'error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _WorkingDirectoryInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WorkingDirectoryInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WorkingDirectoryInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_WorkingDirectoryInfo, a, b); + } +}; +var ArtifactFullFileTarget = class _ArtifactFullFileTarget extends Message { + /** + * Deprecated: Use media instead + * + * @generated from field: exa.codeium_common_pb.ImageData image = 1 [deprecated = true]; + * @deprecated + */ + image; + /** + * If the file is an image file, this will be populated. + * + * @generated from field: exa.codeium_common_pb.Media media = 2; + */ + media; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ArtifactFullFileTarget'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'image', kind: 'message', T: ImageData }, + { no: 2, name: 'media', kind: 'message', T: Media }, + ]); + static fromBinary(bytes, options) { + return new _ArtifactFullFileTarget().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ArtifactFullFileTarget().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ArtifactFullFileTarget().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ArtifactFullFileTarget, a, b); + } +}; +var TextSelection = class _TextSelection extends Message { + /** + * Content of the selection. + * + * @generated from field: string content = 1; + */ + content = ''; + /** + * Inclusive + * + * @generated from field: int32 start_line = 2; + */ + startLine = 0; + /** + * Exclusive + * + * @generated from field: int32 end_line = 3; + */ + endLine = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.TextSelection'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'start_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'end_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _TextSelection().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TextSelection().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TextSelection().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TextSelection, a, b); + } +}; +var ArtifactImageSelection = class _ArtifactImageSelection extends Message { + /** + * Deprecated: Use cropped_media instead + * + * @generated from field: exa.codeium_common_pb.ImageData cropped_image = 1 [deprecated = true]; + * @deprecated + */ + croppedImage; + /** + * Bounding box coordinates in normalized image space (0.0 to 1.0). + * + * @generated from field: float x = 2; + */ + x = 0; + /** + * @generated from field: float y = 3; + */ + y = 0; + /** + * Bounding box dimensions in normalized image space (0.0 to 1.0). + * + * @generated from field: float width = 4; + */ + width = 0; + /** + * @generated from field: float height = 5; + */ + height = 0; + /** + * Cropped media after the bounding box is applied. + * + * @generated from field: exa.codeium_common_pb.Media cropped_media = 6; + */ + croppedMedia; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ArtifactImageSelection'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'cropped_image', kind: 'message', T: ImageData }, + { + no: 2, + name: 'x', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 3, + name: 'y', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 4, + name: 'width', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 5, + name: 'height', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { no: 6, name: 'cropped_media', kind: 'message', T: Media }, + ]); + static fromBinary(bytes, options) { + return new _ArtifactImageSelection().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ArtifactImageSelection().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ArtifactImageSelection().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ArtifactImageSelection, a, b); + } +}; +var ArtifactSelection = class _ArtifactSelection extends Message { + /** + * @generated from oneof exa.codeium_common_pb.ArtifactSelection.selection + */ + selection = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ArtifactSelection'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text_selection', + kind: 'message', + T: TextSelection, + oneof: 'selection', + }, + { + no: 2, + name: 'image_selection', + kind: 'message', + T: ArtifactImageSelection, + oneof: 'selection', + }, + ]); + static fromBinary(bytes, options) { + return new _ArtifactSelection().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ArtifactSelection().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ArtifactSelection().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ArtifactSelection, a, b); + } +}; +var ArtifactSelectionTarget = class _ArtifactSelectionTarget extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.ArtifactSelection selections = 1; + */ + selections = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ArtifactSelectionTarget'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'selections', + kind: 'message', + T: ArtifactSelection, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ArtifactSelectionTarget().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ArtifactSelectionTarget().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ArtifactSelectionTarget().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ArtifactSelectionTarget, a, b); + } +}; +var ArtifactComment = class _ArtifactComment extends Message { + /** + * @generated from field: string artifact_uri = 1; + */ + artifactUri = ''; + /** + * Scope of the comment. + * + * @generated from oneof exa.codeium_common_pb.ArtifactComment.scope + */ + scope = { case: void 0 }; + /** + * @generated from field: string comment = 4; + */ + comment = ''; + /** + * This reflects whether the user has approved or requested changes on + * the artifact. This is only populated if the scope is full_file. + * + * @generated from field: exa.codeium_common_pb.ArtifactApprovalStatus approval_status = 7 [deprecated = true]; + * @deprecated + */ + approvalStatus = ArtifactApprovalStatus.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ArtifactComment'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'artifact_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'full_file', + kind: 'message', + T: ArtifactFullFileTarget, + oneof: 'scope', + }, + { + no: 6, + name: 'selections', + kind: 'message', + T: ArtifactSelectionTarget, + oneof: 'scope', + }, + { + no: 4, + name: 'comment', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'approval_status', + kind: 'enum', + T: proto3.getEnumType(ArtifactApprovalStatus), + }, + ]); + static fromBinary(bytes, options) { + return new _ArtifactComment().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ArtifactComment().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ArtifactComment().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ArtifactComment, a, b); + } +}; +var ArtifactMetadata = class _ArtifactMetadata extends Message { + /** + * @generated from field: exa.codeium_common_pb.ArtifactType artifact_type = 1; + */ + artifactType = ArtifactType.UNSPECIFIED; + /** + * Short summary of the artifact, used to display UI summaries + * when review is requested. + * + * @generated from field: string summary = 2; + */ + summary = ''; + /** + * @generated from field: google.protobuf.Timestamp created_at = 3; + */ + createdAt; + /** + * @generated from field: google.protobuf.Timestamp updated_at = 4; + */ + updatedAt; + /** + * @generated from field: int64 version = 5; + */ + version = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ArtifactMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'artifact_type', + kind: 'enum', + T: proto3.getEnumType(ArtifactType), + }, + { + no: 2, + name: 'summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'created_at', kind: 'message', T: Timestamp }, + { no: 4, name: 'updated_at', kind: 'message', T: Timestamp }, + { + no: 5, + name: 'version', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ArtifactMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ArtifactMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ArtifactMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ArtifactMetadata, a, b); + } +}; +var DiffCommentInfo = class _DiffCommentInfo extends Message { + /** + * @generated from field: optional exa.codeium_common_pb.TextSelection original_selection = 1; + */ + originalSelection; + /** + * @generated from field: optional exa.codeium_common_pb.TextSelection modified_selection = 2; + */ + modifiedSelection; + /** + * @generated from field: string comment = 3; + */ + comment = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.DiffCommentInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'original_selection', + kind: 'message', + T: TextSelection, + opt: true, + }, + { + no: 2, + name: 'modified_selection', + kind: 'message', + T: TextSelection, + opt: true, + }, + { + no: 3, + name: 'comment', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _DiffCommentInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DiffCommentInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DiffCommentInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DiffCommentInfo, a, b); + } +}; +var FileDiffComment = class _FileDiffComment extends Message { + /** + * @generated from field: string file_uri = 1; + */ + fileUri = ''; + /** + * @generated from field: repeated exa.codeium_common_pb.DiffCommentInfo diff_comment_infos = 3; + */ + diffCommentInfos = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.FileDiffComment'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'file_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'diff_comment_infos', + kind: 'message', + T: DiffCommentInfo, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _FileDiffComment().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileDiffComment().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileDiffComment().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FileDiffComment, a, b); + } +}; +var FileCommentInfo = class _FileCommentInfo extends Message { + /** + * @generated from field: string comment = 1; + */ + comment = ''; + /** + * @generated from field: exa.codeium_common_pb.TextSelection selection = 2; + */ + selection; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.FileCommentInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'comment', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'selection', kind: 'message', T: TextSelection }, + ]); + static fromBinary(bytes, options) { + return new _FileCommentInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileCommentInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileCommentInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FileCommentInfo, a, b); + } +}; +var FileComment = class _FileComment extends Message { + /** + * @generated from field: string file_uri = 1; + */ + fileUri = ''; + /** + * @generated from field: repeated exa.codeium_common_pb.FileCommentInfo file_comment_infos = 2; + */ + fileCommentInfos = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.FileComment'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'file_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'file_comment_infos', + kind: 'message', + T: FileCommentInfo, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _FileComment().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileComment().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileComment().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FileComment, a, b); + } +}; +var OnlineMetricsConfig = class _OnlineMetricsConfig extends Message { + /** + * @generated from field: exa.codeium_common_pb.UserStepJudgeConfig user_step_judge_config = 1; + */ + userStepJudgeConfig; + /** + * @generated from field: exa.codeium_common_pb.PlanningModeJudgeConfig planning_mode_judge_config = 2; + */ + planningModeJudgeConfig; + /** + * @generated from field: exa.codeium_common_pb.PromptSectionJudgeConfig prompt_section_judge_config = 3; + */ + promptSectionJudgeConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.OnlineMetricsConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'user_step_judge_config', + kind: 'message', + T: UserStepJudgeConfig, + }, + { + no: 2, + name: 'planning_mode_judge_config', + kind: 'message', + T: PlanningModeJudgeConfig, + }, + { + no: 3, + name: 'prompt_section_judge_config', + kind: 'message', + T: PromptSectionJudgeConfig, + }, + ]); + static fromBinary(bytes, options) { + return new _OnlineMetricsConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _OnlineMetricsConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _OnlineMetricsConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_OnlineMetricsConfig, a, b); + } +}; +var MetricsSamplingConfig = class _MetricsSamplingConfig extends Message { + /** + * The sampling strategy to use + * + * @generated from oneof exa.codeium_common_pb.MetricsSamplingConfig.sampling_strategy + */ + samplingStrategy = { case: void 0 }; + /** + * @generated from field: optional int64 random_seed = 3; + */ + randomSeed; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.MetricsSamplingConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'uniform', + kind: 'message', + T: SamplingStrategyUniform, + oneof: 'sampling_strategy', + }, + { + no: 2, + name: 'generator_metadata_aware', + kind: 'message', + T: SamplingStrategyGeneratorMetadataAware, + oneof: 'sampling_strategy', + }, + { no: 3, name: 'random_seed', kind: 'scalar', T: 3, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _MetricsSamplingConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MetricsSamplingConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MetricsSamplingConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_MetricsSamplingConfig, a, b); + } +}; +var SamplingStrategyUniform = class _SamplingStrategyUniform extends Message { + /** + * Sampling rate must be between 0.0 and 1.0 + * + * @generated from field: float sampling_rate = 1; + */ + samplingRate = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.SamplingStrategyUniform'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'sampling_rate', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + ]); + static fromBinary(bytes, options) { + return new _SamplingStrategyUniform().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SamplingStrategyUniform().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SamplingStrategyUniform().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SamplingStrategyUniform, a, b); + } +}; +var SamplingStrategyGeneratorMetadataAware = class _SamplingStrategyGeneratorMetadataAware extends Message { + /** + * Target rate if the generator metadata index is within the range + * [start_generator_metadata_index, end_generator_metadata_index] + * + * @generated from field: float target_sampling_rate = 1; + */ + targetSamplingRate = 0; + /** + * Baseline rate if the generator metadata index is outside the range + * [start_generator_metadata_index, end_generator_metadata_index] + * + * @generated from field: float baseline_sampling_rate = 2; + */ + baselineSamplingRate = 0; + /** + * Start of selected range (inclusive) + * + * @generated from field: int32 start_generator_metadata_index = 3; + */ + startGeneratorMetadataIndex = 0; + /** + * End of selected range (inclusive) + * + * @generated from field: int32 end_generator_metadata_index = 4; + */ + endGeneratorMetadataIndex = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.codeium_common_pb.SamplingStrategyGeneratorMetadataAware'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'target_sampling_rate', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 2, + name: 'baseline_sampling_rate', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 3, + name: 'start_generator_metadata_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'end_generator_metadata_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _SamplingStrategyGeneratorMetadataAware().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _SamplingStrategyGeneratorMetadataAware().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _SamplingStrategyGeneratorMetadataAware().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_SamplingStrategyGeneratorMetadataAware, a, b); + } +}; +var PromptSectionJudgeConfig = class _PromptSectionJudgeConfig extends Message { + /** + * @generated from field: bool enabled = 1; + */ + enabled = false; + /** + * @generated from field: optional exa.codeium_common_pb.MetricsSamplingConfig sampling_config = 2; + */ + samplingConfig; + /** + * @generated from field: exa.codeium_common_pb.Model judge_model = 3; + */ + judgeModel = Model.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PromptSectionJudgeConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'sampling_config', + kind: 'message', + T: MetricsSamplingConfig, + opt: true, + }, + { no: 3, name: 'judge_model', kind: 'enum', T: proto3.getEnumType(Model) }, + ]); + static fromBinary(bytes, options) { + return new _PromptSectionJudgeConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptSectionJudgeConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptSectionJudgeConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PromptSectionJudgeConfig, a, b); + } +}; +var UserStepJudgeConfig = class _UserStepJudgeConfig extends Message { + /** + * @generated from field: bool enabled = 1; + */ + enabled = false; + /** + * @generated from field: optional exa.codeium_common_pb.MetricsSamplingConfig sampling_config = 2; + */ + samplingConfig; + /** + * @generated from field: exa.codeium_common_pb.Model judge_model = 3; + */ + judgeModel = Model.UNSPECIFIED; + /** + * @generated from field: uint32 max_tokens = 4; + */ + maxTokens = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.UserStepJudgeConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'sampling_config', + kind: 'message', + T: MetricsSamplingConfig, + opt: true, + }, + { no: 3, name: 'judge_model', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 4, + name: 'max_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _UserStepJudgeConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserStepJudgeConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserStepJudgeConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserStepJudgeConfig, a, b); + } +}; +var PlanningModeJudgeConfig = class _PlanningModeJudgeConfig extends Message { + /** + * @generated from field: optional bool enabled = 1; + */ + enabled; + /** + * @generated from field: optional exa.codeium_common_pb.MetricsSamplingConfig sampling_config = 2; + */ + samplingConfig; + /** + * @generated from field: exa.codeium_common_pb.Model judge_model = 3; + */ + judgeModel = Model.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.PlanningModeJudgeConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { + no: 2, + name: 'sampling_config', + kind: 'message', + T: MetricsSamplingConfig, + opt: true, + }, + { no: 3, name: 'judge_model', kind: 'enum', T: proto3.getEnumType(Model) }, + ]); + static fromBinary(bytes, options) { + return new _PlanningModeJudgeConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PlanningModeJudgeConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PlanningModeJudgeConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PlanningModeJudgeConfig, a, b); + } +}; +var Point2 = class _Point2 extends Message { + /** + * @generated from field: int32 x = 1; + */ + x = 0; + /** + * @generated from field: int32 y = 2; + */ + y = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Point2'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'x', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'y', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _Point2().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Point2().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Point2().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Point2, a, b); + } +}; +var JetskiTelemetryExtension = class _JetskiTelemetryExtension extends Message { + /** + * @generated from field: string ide_name = 16; + */ + ideName = ''; + /** + * @generated from field: string ide_version = 17; + */ + ideVersion = ''; + /** + * @generated from field: string os = 18; + */ + os = ''; + /** + * @generated from field: string arch = 19; + */ + arch = ''; + /** + * @generated from field: string user_tier_id = 22; + */ + userTierId = ''; + /** + * @generated from field: repeated string user_tags = 23; + */ + userTags = []; + /** + * @generated from field: bool is_redacted = 24; + */ + isRedacted = false; + /** + * @generated from oneof exa.codeium_common_pb.JetskiTelemetryExtension.payload + */ + payload = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.JetskiTelemetryExtension'; + static fields = proto3.util.newFieldList(() => [ + { + no: 16, + name: 'ide_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 17, + name: 'ide_version', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 18, + name: 'os', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 19, + name: 'arch', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 22, + name: 'user_tier_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 23, name: 'user_tags', kind: 'scalar', T: 9, repeated: true }, + { + no: 24, + name: 'is_redacted', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'analytics_event_metadata', + kind: 'message', + T: AnalyticsEventMetadata, + oneof: 'payload', + }, + { + no: 15, + name: 'error_trace_metadata', + kind: 'message', + T: ErrorTraceMetadata, + oneof: 'payload', + }, + { + no: 26, + name: 'observability_data', + kind: 'message', + T: ObservabilityData, + oneof: 'payload', + }, + ]); + static fromBinary(bytes, options) { + return new _JetskiTelemetryExtension().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _JetskiTelemetryExtension().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _JetskiTelemetryExtension().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_JetskiTelemetryExtension, a, b); + } +}; +var ExtraMetadata = class _ExtraMetadata extends Message { + /** + * @generated from field: string key = 1; + */ + key = ''; + /** + * @generated from field: string value = 2; + */ + value = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ExtraMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'value', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ExtraMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ExtraMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ExtraMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ExtraMetadata, a, b); + } +}; +var Experiment = class _Experiment extends Message { + /** + * @generated from field: string key = 1; + */ + key = ''; + /** + * @generated from field: bool enabled = 2; + */ + enabled = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.Experiment'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _Experiment().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Experiment().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Experiment().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Experiment, a, b); + } +}; +var AnalyticsEventMetadata = class _AnalyticsEventMetadata extends Message { + /** + * The type of the event. + * + * @generated from field: string event_type = 1; + */ + eventType = ''; + /** + * Additional metadata associated with the event. + * + * @generated from field: repeated exa.codeium_common_pb.ExtraMetadata extra = 2; + */ + extra = []; + /** + * Experiments active at the time of the event. + * + * @generated from field: repeated exa.codeium_common_pb.Experiment experiments = 3; + */ + experiments = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.AnalyticsEventMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'event_type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'extra', kind: 'message', T: ExtraMetadata, repeated: true }, + { + no: 3, + name: 'experiments', + kind: 'message', + T: Experiment, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _AnalyticsEventMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AnalyticsEventMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AnalyticsEventMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AnalyticsEventMetadata, a, b); + } +}; +var ErrorTraceMetadata = class _ErrorTraceMetadata extends Message { + /** + * @generated from field: exa.codeium_common_pb.ErrorTrace error_trace = 1; + */ + errorTrace; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ErrorTraceMetadata'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'error_trace', kind: 'message', T: ErrorTrace }, + ]); + static fromBinary(bytes, options) { + return new _ErrorTraceMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ErrorTraceMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ErrorTraceMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ErrorTraceMetadata, a, b); + } +}; +var ObservabilityData = class _ObservabilityData extends Message { + /** + * @generated from field: string type = 1; + */ + type = ''; + /** + * Data that is safe to retain without redaction. + * + * @generated from field: repeated exa.codeium_common_pb.ExtraMetadata non_sensitive_data = 2; + */ + nonSensitiveData = []; + /** + * Data that may contain sensitive information and should be redacted in + * certain contexts. + * + * @generated from field: repeated exa.codeium_common_pb.ExtraMetadata sensitive_data = 3; + */ + sensitiveData = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ObservabilityData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'non_sensitive_data', + kind: 'message', + T: ExtraMetadata, + repeated: true, + }, + { + no: 3, + name: 'sensitive_data', + kind: 'message', + T: ExtraMetadata, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ObservabilityData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ObservabilityData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ObservabilityData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ObservabilityData, a, b); + } +}; +var LogEvent = class _LogEvent extends Message { + /** + * @generated from field: int64 event_time_ms = 1; + */ + eventTimeMs = protoInt64.zero; + /** + * @generated from field: bytes source_extension = 6; + */ + sourceExtension = new Uint8Array(0); + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.LogEvent'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'event_time_ms', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 6, + name: 'source_extension', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + ]); + static fromBinary(bytes, options) { + return new _LogEvent().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LogEvent().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LogEvent().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LogEvent, a, b); + } +}; +var ClientInfo = class _ClientInfo extends Message { + /** + * We use int to avoid leaking the real enum + * + * @generated from field: int32 client_type = 1; + */ + clientType = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.ClientInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'client_type', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ClientInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ClientInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ClientInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ClientInfo, a, b); + } +}; +var LogRequest = class _LogRequest extends Message { + /** + * @generated from field: exa.codeium_common_pb.ClientInfo client_info = 1; + */ + clientInfo; + /** + * We use int to avoid leaking the real enum + * + * @generated from field: int32 log_source = 2; + */ + logSource = 0; + /** + * @generated from field: repeated exa.codeium_common_pb.LogEvent log_events = 3; + */ + logEvents = []; + /** + * @generated from field: int64 request_time_ms = 4; + */ + requestTimeMs = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.LogRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'client_info', kind: 'message', T: ClientInfo }, + { + no: 2, + name: 'log_source', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { no: 3, name: 'log_events', kind: 'message', T: LogEvent, repeated: true }, + { + no: 4, + name: 'request_time_ms', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _LogRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LogRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LogRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LogRequest, a, b); + } +}; +var LogResponse = class _LogResponse extends Message { + /** + * @generated from field: int64 next_request_wait_millis = 1; + */ + nextRequestWaitMillis = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.codeium_common_pb.LogResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'next_request_wait_millis', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _LogResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LogResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LogResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LogResponse, a, b); + } +}; + +// exa/proto_ts/dist/exa/diff_action_pb/diff_action_pb.js +var UnifiedDiffLineType; +(function (UnifiedDiffLineType2) { + UnifiedDiffLineType2[(UnifiedDiffLineType2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + UnifiedDiffLineType2[(UnifiedDiffLineType2['INSERT'] = 1)] = 'INSERT'; + UnifiedDiffLineType2[(UnifiedDiffLineType2['DELETE'] = 2)] = 'DELETE'; + UnifiedDiffLineType2[(UnifiedDiffLineType2['UNCHANGED'] = 3)] = 'UNCHANGED'; +})(UnifiedDiffLineType || (UnifiedDiffLineType = {})); +proto3.util.setEnumType( + UnifiedDiffLineType, + 'exa.diff_action_pb.UnifiedDiffLineType', + [ + { no: 0, name: 'UNIFIED_DIFF_LINE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'UNIFIED_DIFF_LINE_TYPE_INSERT' }, + { no: 2, name: 'UNIFIED_DIFF_LINE_TYPE_DELETE' }, + { no: 3, name: 'UNIFIED_DIFF_LINE_TYPE_UNCHANGED' }, + ], +); +var DiffChangeType; +(function (DiffChangeType2) { + DiffChangeType2[(DiffChangeType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + DiffChangeType2[(DiffChangeType2['INSERT'] = 1)] = 'INSERT'; + DiffChangeType2[(DiffChangeType2['DELETE'] = 2)] = 'DELETE'; + DiffChangeType2[(DiffChangeType2['UNCHANGED'] = 3)] = 'UNCHANGED'; +})(DiffChangeType || (DiffChangeType = {})); +proto3.util.setEnumType(DiffChangeType, 'exa.diff_action_pb.DiffChangeType', [ + { no: 0, name: 'DIFF_CHANGE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'DIFF_CHANGE_TYPE_INSERT' }, + { no: 2, name: 'DIFF_CHANGE_TYPE_DELETE' }, + { no: 3, name: 'DIFF_CHANGE_TYPE_UNCHANGED' }, +]); +var DiffType; +(function (DiffType2) { + DiffType2[(DiffType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + DiffType2[(DiffType2['UNIFIED'] = 1)] = 'UNIFIED'; + DiffType2[(DiffType2['CHARACTER'] = 2)] = 'CHARACTER'; + DiffType2[(DiffType2['COMBO'] = 3)] = 'COMBO'; + DiffType2[(DiffType2['TMP_SUPERCOMPLETE'] = 4)] = 'TMP_SUPERCOMPLETE'; + DiffType2[(DiffType2['TMP_TAB_JUMP'] = 5)] = 'TMP_TAB_JUMP'; +})(DiffType || (DiffType = {})); +proto3.util.setEnumType(DiffType, 'exa.diff_action_pb.DiffType', [ + { no: 0, name: 'DIFF_TYPE_UNSPECIFIED' }, + { no: 1, name: 'DIFF_TYPE_UNIFIED' }, + { no: 2, name: 'DIFF_TYPE_CHARACTER' }, + { no: 3, name: 'DIFF_TYPE_COMBO' }, + { no: 4, name: 'DIFF_TYPE_TMP_SUPERCOMPLETE' }, + { no: 5, name: 'DIFF_TYPE_TMP_TAB_JUMP' }, +]); +var UnifiedDiff = class _UnifiedDiff extends Message { + /** + * @generated from field: repeated exa.diff_action_pb.UnifiedDiff.UnifiedDiffLine lines = 3; + */ + lines = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.diff_action_pb.UnifiedDiff'; + static fields = proto3.util.newFieldList(() => [ + { + no: 3, + name: 'lines', + kind: 'message', + T: UnifiedDiff_UnifiedDiffLine, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _UnifiedDiff().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UnifiedDiff().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UnifiedDiff().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UnifiedDiff, a, b); + } +}; +var UnifiedDiff_UnifiedDiffLine = class _UnifiedDiff_UnifiedDiffLine extends Message { + /** + * @generated from field: string text = 1; + */ + text = ''; + /** + * @generated from field: exa.diff_action_pb.UnifiedDiffLineType type = 2; + */ + type = UnifiedDiffLineType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.diff_action_pb.UnifiedDiff.UnifiedDiffLine'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(UnifiedDiffLineType), + }, + ]); + static fromBinary(bytes, options) { + return new _UnifiedDiff_UnifiedDiffLine().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UnifiedDiff_UnifiedDiffLine().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UnifiedDiff_UnifiedDiffLine().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_UnifiedDiff_UnifiedDiffLine, a, b); + } +}; +var DiffBlock = class _DiffBlock extends Message { + /** + * 0-indexed (start & end). + * Negative value means append at the end. + * + * @generated from field: int32 start_line = 1; + */ + startLine = 0; + /** + * @generated from field: int32 end_line = 2; + */ + endLine = 0; + /** + * @generated from field: exa.diff_action_pb.UnifiedDiff unified_diff = 3; + */ + unifiedDiff; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.diff_action_pb.DiffBlock'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'start_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'end_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { no: 3, name: 'unified_diff', kind: 'message', T: UnifiedDiff }, + ]); + static fromBinary(bytes, options) { + return new _DiffBlock().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DiffBlock().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DiffBlock().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DiffBlock, a, b); + } +}; +var CharacterDiffChange = class _CharacterDiffChange extends Message { + /** + * @generated from field: string text = 1; + */ + text = ''; + /** + * @generated from field: exa.diff_action_pb.DiffChangeType type = 2; + */ + type = DiffChangeType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.diff_action_pb.CharacterDiffChange'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(DiffChangeType), + }, + ]); + static fromBinary(bytes, options) { + return new _CharacterDiffChange().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CharacterDiffChange().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CharacterDiffChange().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CharacterDiffChange, a, b); + } +}; +var CharacterDiff = class _CharacterDiff extends Message { + /** + * Must be in order from start to end of the diff. If you iterated through the + * array in order, you could construct the new version of the diff (accept + * command) by using the unchanged and insertions, and you could construct the + * old version (reject command) by using unchanged and deletions. + * + * @generated from field: repeated exa.diff_action_pb.CharacterDiffChange changes = 1; + */ + changes = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.diff_action_pb.CharacterDiff'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'changes', + kind: 'message', + T: CharacterDiffChange, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CharacterDiff().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CharacterDiff().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CharacterDiff().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CharacterDiff, a, b); + } +}; +var ComboDiffLine = class _ComboDiffLine extends Message { + /** + * The full line of text + * + * @generated from field: string text = 1; + */ + text = ''; + /** + * Whether the line contains insertions/deletions or is unchanged. + * + * @generated from field: exa.diff_action_pb.DiffChangeType type = 2; + */ + type = DiffChangeType.UNSPECIFIED; + /** + * The character by character diff of the line which stores the specific + * characters that are of the same change type as the type field. To further + * clarify, the only types of changes within this characterDiff should be + * unchanged and the type specfied in the type field because each line should + * only have one type of change (and unchanged for parts if its insert or + * delete). + * + * @generated from field: exa.diff_action_pb.CharacterDiff character_diff = 3; + */ + characterDiff; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.diff_action_pb.ComboDiffLine'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(DiffChangeType), + }, + { no: 3, name: 'character_diff', kind: 'message', T: CharacterDiff }, + ]); + static fromBinary(bytes, options) { + return new _ComboDiffLine().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ComboDiffLine().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ComboDiffLine().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ComboDiffLine, a, b); + } +}; +var ComboDiff = class _ComboDiff extends Message { + /** + * For modified lines, deletions always come before insertions. + * + * @generated from field: repeated exa.diff_action_pb.ComboDiffLine lines = 1; + */ + lines = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.diff_action_pb.ComboDiff'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'lines', kind: 'message', T: ComboDiffLine, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _ComboDiff().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ComboDiff().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ComboDiff().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ComboDiff, a, b); + } +}; +var DiffSet = class _DiffSet extends Message { + /** + * @generated from field: exa.diff_action_pb.UnifiedDiff unified_diff = 1; + */ + unifiedDiff; + /** + * @generated from field: exa.diff_action_pb.CharacterDiff character_diff = 2; + */ + characterDiff; + /** + * @generated from field: exa.diff_action_pb.ComboDiff combo_diff = 3; + */ + comboDiff; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.diff_action_pb.DiffSet'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'unified_diff', kind: 'message', T: UnifiedDiff }, + { no: 2, name: 'character_diff', kind: 'message', T: CharacterDiff }, + { no: 3, name: 'combo_diff', kind: 'message', T: ComboDiff }, + ]); + static fromBinary(bytes, options) { + return new _DiffSet().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DiffSet().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DiffSet().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DiffSet, a, b); + } +}; +var DiffList = class _DiffList extends Message { + /** + * @generated from field: repeated exa.diff_action_pb.DiffBlock diffs = 2; + */ + diffs = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.diff_action_pb.DiffList'; + static fields = proto3.util.newFieldList(() => [ + { no: 2, name: 'diffs', kind: 'message', T: DiffBlock, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _DiffList().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DiffList().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DiffList().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DiffList, a, b); + } +}; + +// exa/proto_ts/dist/exa/chat_pb/chat_pb.js +var ChatFeedbackType; +(function (ChatFeedbackType2) { + ChatFeedbackType2[(ChatFeedbackType2['FEEDBACK_TYPE_UNSPECIFIED'] = 0)] = + 'FEEDBACK_TYPE_UNSPECIFIED'; + ChatFeedbackType2[(ChatFeedbackType2['FEEDBACK_TYPE_ACCEPT'] = 1)] = + 'FEEDBACK_TYPE_ACCEPT'; + ChatFeedbackType2[(ChatFeedbackType2['FEEDBACK_TYPE_REJECT'] = 2)] = + 'FEEDBACK_TYPE_REJECT'; + ChatFeedbackType2[(ChatFeedbackType2['FEEDBACK_TYPE_COPIED'] = 3)] = + 'FEEDBACK_TYPE_COPIED'; + ChatFeedbackType2[(ChatFeedbackType2['FEEDBACK_TYPE_ACCEPT_DIFF'] = 4)] = + 'FEEDBACK_TYPE_ACCEPT_DIFF'; + ChatFeedbackType2[(ChatFeedbackType2['FEEDBACK_TYPE_REJECT_DIFF'] = 5)] = + 'FEEDBACK_TYPE_REJECT_DIFF'; + ChatFeedbackType2[(ChatFeedbackType2['FEEDBACK_TYPE_APPLY_DIFF'] = 6)] = + 'FEEDBACK_TYPE_APPLY_DIFF'; + ChatFeedbackType2[(ChatFeedbackType2['FEEDBACK_TYPE_INSERT_AT_CURSOR'] = 7)] = + 'FEEDBACK_TYPE_INSERT_AT_CURSOR'; +})(ChatFeedbackType || (ChatFeedbackType = {})); +proto3.util.setEnumType(ChatFeedbackType, 'exa.chat_pb.ChatFeedbackType', [ + { no: 0, name: 'FEEDBACK_TYPE_UNSPECIFIED' }, + { no: 1, name: 'FEEDBACK_TYPE_ACCEPT' }, + { no: 2, name: 'FEEDBACK_TYPE_REJECT' }, + { no: 3, name: 'FEEDBACK_TYPE_COPIED' }, + { no: 4, name: 'FEEDBACK_TYPE_ACCEPT_DIFF' }, + { no: 5, name: 'FEEDBACK_TYPE_REJECT_DIFF' }, + { no: 6, name: 'FEEDBACK_TYPE_APPLY_DIFF' }, + { no: 7, name: 'FEEDBACK_TYPE_INSERT_AT_CURSOR' }, +]); +var ChatIntentType; +(function (ChatIntentType2) { + ChatIntentType2[(ChatIntentType2['CHAT_INTENT_UNSPECIFIED'] = 0)] = + 'CHAT_INTENT_UNSPECIFIED'; + ChatIntentType2[(ChatIntentType2['CHAT_INTENT_GENERIC'] = 1)] = + 'CHAT_INTENT_GENERIC'; + ChatIntentType2[(ChatIntentType2['CHAT_INTENT_CODE_BLOCK_REFACTOR'] = 6)] = + 'CHAT_INTENT_CODE_BLOCK_REFACTOR'; + ChatIntentType2[(ChatIntentType2['CHAT_INTENT_GENERATE_CODE'] = 9)] = + 'CHAT_INTENT_GENERATE_CODE'; + ChatIntentType2[(ChatIntentType2['CHAT_INTENT_FAST_APPLY'] = 12)] = + 'CHAT_INTENT_FAST_APPLY'; +})(ChatIntentType || (ChatIntentType = {})); +proto3.util.setEnumType(ChatIntentType, 'exa.chat_pb.ChatIntentType', [ + { no: 0, name: 'CHAT_INTENT_UNSPECIFIED' }, + { no: 1, name: 'CHAT_INTENT_GENERIC' }, + { no: 6, name: 'CHAT_INTENT_CODE_BLOCK_REFACTOR' }, + { no: 9, name: 'CHAT_INTENT_GENERATE_CODE' }, + { no: 12, name: 'CHAT_INTENT_FAST_APPLY' }, +]); +var CacheControlType; +(function (CacheControlType2) { + CacheControlType2[(CacheControlType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CacheControlType2[(CacheControlType2['EPHEMERAL'] = 1)] = 'EPHEMERAL'; +})(CacheControlType || (CacheControlType = {})); +proto3.util.setEnumType(CacheControlType, 'exa.chat_pb.CacheControlType', [ + { no: 0, name: 'CACHE_CONTROL_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CACHE_CONTROL_TYPE_EPHEMERAL' }, +]); +var CodeBlockInfo = class _CodeBlockInfo extends Message { + /** + * @generated from field: string raw_source = 1; + */ + rawSource = ''; + /** + * 0-indexed (start & end). + * Start position of the code block. + * + * @generated from field: int32 start_line = 2; + */ + startLine = 0; + /** + * @generated from field: int32 start_col = 3; + */ + startCol = 0; + /** + * End position of the code block. + * + * @generated from field: int32 end_line = 4; + */ + endLine = 0; + /** + * Exclusive of (end_line, end_col). + * + * @generated from field: int32 end_col = 5; + */ + endCol = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.CodeBlockInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'raw_source', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'start_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'start_col', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'end_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'end_col', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CodeBlockInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeBlockInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeBlockInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeBlockInfo, a, b); + } +}; +var ChatMetrics = class _ChatMetrics extends Message { + /** + * Duration of the actual chat response generation stream. + * + * @generated from field: uint64 response_stream_latency_ms = 1; + */ + responseStreamLatencyMs = protoInt64.zero; + /** + * Duration of the RefreshContext() call. + * + * @generated from field: uint64 refresh_context_latency_ms = 2; + */ + refreshContextLatencyMs = protoInt64.zero; + /** + * Breakdown of steps within RefreshContext(). + * + * @generated from field: uint64 should_get_local_context_for_chat_latency_ms = 3; + */ + shouldGetLocalContextForChatLatencyMs = protoInt64.zero; + /** + * @generated from field: bool should_get_local_context_for_chat = 4; + */ + shouldGetLocalContextForChat = false; + /** + * @generated from field: uint64 compute_change_events_latency_ms = 5; + */ + computeChangeEventsLatencyMs = protoInt64.zero; + /** + * Duration of the ContextToChatPrompt() call. + * + * @generated from field: uint64 context_to_chat_prompt_latency_ms = 6; + */ + contextToChatPromptLatencyMs = protoInt64.zero; + /** + * Number of tokens ultimately used in the prompt. + * + * @generated from field: int32 num_prompt_tokens = 7; + */ + numPromptTokens = 0; + /** + * @generated from field: int32 num_system_prompt_tokens = 8; + */ + numSystemPromptTokens = 0; + /** + * May not be exactly equal to prompt + system prompts. Since in some cases, + * we will use approximate tokenizers for the above two token counts. Whereas + * for model providers that support returning the exact input token count, we + * will override it with that value. + * + * @generated from field: uint64 num_input_tokens = 16; + */ + numInputTokens = protoInt64.zero; + /** + * Timestamp when the chat request hit the language server. + * + * @generated from field: google.protobuf.Timestamp start_timestamp = 9; + */ + startTimestamp; + /** + * End timestamp upon which the chat response was completely generated and + * sent back to the client. + * + * @generated from field: google.protobuf.Timestamp end_timestamp = 10; + */ + endTimestamp; + /** + * Absolute path of the active document when the chat request was made. + * + * @generated from field: string active_document_absolute_path = 11; + */ + activeDocumentAbsolutePath = ''; + /** + * The last code context item that was active when the chat request was made. + * + * @generated from field: exa.codeium_common_pb.CodeContextItem last_active_code_context_item = 12; + */ + lastActiveCodeContextItem; + /** + * Number of files that were in the index. + * + * @generated from field: uint64 num_indexed_files = 13; + */ + numIndexedFiles = protoInt64.zero; + /** + * Number of code context items in the index. + * + * @generated from field: uint64 num_indexed_code_context_items = 14; + */ + numIndexedCodeContextItems = protoInt64.zero; + /** + * The model used to generate the chat response. + * + * @generated from field: exa.codeium_common_pb.Model model = 15; + */ + model = Model.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMetrics'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'response_stream_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'refresh_context_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'should_get_local_context_for_chat_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 4, + name: 'should_get_local_context_for_chat', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'compute_change_events_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 6, + name: 'context_to_chat_prompt_latency_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 7, + name: 'num_prompt_tokens', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 8, + name: 'num_system_prompt_tokens', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 16, + name: 'num_input_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { no: 9, name: 'start_timestamp', kind: 'message', T: Timestamp }, + { no: 10, name: 'end_timestamp', kind: 'message', T: Timestamp }, + { + no: 11, + name: 'active_document_absolute_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'last_active_code_context_item', + kind: 'message', + T: CodeContextItem, + }, + { + no: 13, + name: 'num_indexed_files', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 14, + name: 'num_indexed_code_context_items', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { no: 15, name: 'model', kind: 'enum', T: proto3.getEnumType(Model) }, + ]); + static fromBinary(bytes, options) { + return new _ChatMetrics().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMetrics().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMetrics().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMetrics, a, b); + } +}; +var IntentGeneric = class _IntentGeneric extends Message { + /** + * TODO(matt): Deprecate text in favor of items. + * + * @generated from field: string text = 1; + */ + text = ''; + /** + * @generated from field: repeated exa.codeium_common_pb.TextOrScopeItem items = 2; + */ + items = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.IntentGeneric'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'items', + kind: 'message', + T: TextOrScopeItem, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _IntentGeneric().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IntentGeneric().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IntentGeneric().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IntentGeneric, a, b); + } +}; +var IntentCodeBlockRefactor = class _IntentCodeBlockRefactor extends Message { + /** + * @generated from field: exa.chat_pb.CodeBlockInfo code_block_info = 1; + */ + codeBlockInfo; + /** + * @generated from field: exa.codeium_common_pb.Language language = 2; + */ + language = Language.UNSPECIFIED; + /** + * @generated from field: string file_path_migrate_me_to_uri = 3 [deprecated = true]; + * @deprecated + */ + filePathMigrateMeToUri = ''; + /** + * @generated from field: string uri = 5; + */ + uri = ''; + /** + * @generated from field: string refactor_description = 4; + */ + refactorDescription = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.IntentCodeBlockRefactor'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'code_block_info', kind: 'message', T: CodeBlockInfo }, + { no: 2, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { + no: 3, + name: 'file_path_migrate_me_to_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'refactor_description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _IntentCodeBlockRefactor().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IntentCodeBlockRefactor().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IntentCodeBlockRefactor().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IntentCodeBlockRefactor, a, b); + } +}; +var IntentGenerateCode = class _IntentGenerateCode extends Message { + /** + * @generated from field: string instruction = 1; + */ + instruction = ''; + /** + * @generated from field: exa.codeium_common_pb.Language language = 2; + */ + language = Language.UNSPECIFIED; + /** + * @generated from field: string file_path_migrate_me_to_uri = 3 [deprecated = true]; + * @deprecated + */ + filePathMigrateMeToUri = ''; + /** + * @generated from field: string uri = 5; + */ + uri = ''; + /** + * Line to insert the generated code into. + * + * @generated from field: int32 line_number = 4; + */ + lineNumber = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.IntentGenerateCode'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'instruction', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { + no: 3, + name: 'file_path_migrate_me_to_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'line_number', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _IntentGenerateCode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IntentGenerateCode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IntentGenerateCode().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IntentGenerateCode, a, b); + } +}; +var IntentFastApply = class _IntentFastApply extends Message { + /** + * @generated from field: string diff_outline = 1; + */ + diffOutline = ''; + /** + * @generated from field: exa.codeium_common_pb.Language language = 2; + */ + language = Language.UNSPECIFIED; + /** + * @generated from field: exa.chat_pb.CodeBlockInfo old_code = 3; + */ + oldCode; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.IntentFastApply'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'diff_outline', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { no: 3, name: 'old_code', kind: 'message', T: CodeBlockInfo }, + ]); + static fromBinary(bytes, options) { + return new _IntentFastApply().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IntentFastApply().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IntentFastApply().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IntentFastApply, a, b); + } +}; +var ChatMessageIntent = class _ChatMessageIntent extends Message { + /** + * @generated from oneof exa.chat_pb.ChatMessageIntent.intent + */ + intent = { case: void 0 }; + /** + * The number of tokens in the intent prompt. This will only be populated + * after the language server has processed the intent message. + * + * @generated from field: uint32 num_tokens = 12; + */ + numTokens = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessageIntent'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'generic', + kind: 'message', + T: IntentGeneric, + oneof: 'intent', + }, + { + no: 6, + name: 'code_block_refactor', + kind: 'message', + T: IntentCodeBlockRefactor, + oneof: 'intent', + }, + { + no: 9, + name: 'generate_code', + kind: 'message', + T: IntentGenerateCode, + oneof: 'intent', + }, + { + no: 13, + name: 'fast_apply', + kind: 'message', + T: IntentFastApply, + oneof: 'intent', + }, + { + no: 12, + name: 'num_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessageIntent().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessageIntent().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessageIntent().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessageIntent, a, b); + } +}; +var ChatMessageActionSearch = class _ChatMessageActionSearch extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessageActionSearch'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _ChatMessageActionSearch().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessageActionSearch().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessageActionSearch().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessageActionSearch, a, b); + } +}; +var ChatMessageActionEdit = class _ChatMessageActionEdit extends Message { + /** + * Metadata to inform where the edit should be applied. + * + * @generated from field: string file_path_migrate_me_to_uri = 1 [deprecated = true]; + * @deprecated + */ + filePathMigrateMeToUri = ''; + /** + * @generated from field: string uri = 6; + */ + uri = ''; + /** + * The diff that should be applied on the file. + * + * @generated from field: exa.diff_action_pb.DiffBlock diff = 2; + */ + diff; + /** + * Additional metadata about the edit action. + * + * TODO: Deprecate this in favor of diff-level language. + * + * @generated from field: exa.codeium_common_pb.Language language = 3; + */ + language = Language.UNSPECIFIED; + /** + * Generic text to pass along with the edit (ie. an explanation). Text can be + * either before or after the diff. This primarily impacts rendering. + * + * @generated from field: string text_pre = 4; + */ + textPre = ''; + /** + * @generated from field: string text_post = 5; + */ + textPost = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessageActionEdit'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'file_path_migrate_me_to_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'diff', kind: 'message', T: DiffBlock }, + { no: 3, name: 'language', kind: 'enum', T: proto3.getEnumType(Language) }, + { + no: 4, + name: 'text_pre', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'text_post', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessageActionEdit().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessageActionEdit().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessageActionEdit().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessageActionEdit, a, b); + } +}; +var ChatMessageActionGeneric = class _ChatMessageActionGeneric extends Message { + /** + * @generated from field: string text = 1; + */ + text = ''; + /** + * Markdown text to be displayed on the client (includes citations) + * + * @generated from field: string display_text = 2; + */ + displayText = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessageActionGeneric'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'display_text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessageActionGeneric().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessageActionGeneric().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessageActionGeneric().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessageActionGeneric, a, b); + } +}; +var ChatMessageStatusContextRelevancy = class _ChatMessageStatusContextRelevancy extends Message { + /** + * @generated from field: bool is_loading = 1; + */ + isLoading = false; + /** + * @generated from field: bool is_relevant = 2; + */ + isRelevant = false; + /** + * @generated from field: repeated string query_suggestions = 3; + */ + querySuggestions = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessageStatusContextRelevancy'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'is_loading', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'is_relevant', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 3, name: 'query_suggestions', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessageStatusContextRelevancy().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessageStatusContextRelevancy().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _ChatMessageStatusContextRelevancy().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessageStatusContextRelevancy, a, b); + } +}; +var ChatMessageStatus = class _ChatMessageStatus extends Message { + /** + * @generated from oneof exa.chat_pb.ChatMessageStatus.status + */ + status = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessageStatus'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'context_relevancy', + kind: 'message', + T: ChatMessageStatusContextRelevancy, + oneof: 'status', + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessageStatus().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessageStatus().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessageStatus().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessageStatus, a, b); + } +}; +var ChatMessageError = class _ChatMessageError extends Message { + /** + * @generated from field: string text = 1; + */ + text = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessageError'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessageError().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessageError().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessageError().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessageError, a, b); + } +}; +var ChatMessageAction = class _ChatMessageAction extends Message { + /** + * @generated from oneof exa.chat_pb.ChatMessageAction.action + */ + action = { case: void 0 }; + /** + * @generated from field: uint32 num_tokens = 2; + */ + numTokens = 0; + /** + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem context_items = 4; + */ + contextItems = []; + /** + * @generated from field: exa.chat_pb.ChatIntentType latest_intent = 6; + */ + latestIntent = ChatIntentType.CHAT_INTENT_UNSPECIFIED; + /** + * Metadata about the chat generation. + * + * @generated from field: exa.chat_pb.ChatMetrics generation_stats = 7; + */ + generationStats; + /** + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseItemWithMetadata knowledge_base_items = 8; + */ + knowledgeBaseItems = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessageAction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'generic', + kind: 'message', + T: ChatMessageActionGeneric, + oneof: 'action', + }, + { + no: 3, + name: 'edit', + kind: 'message', + T: ChatMessageActionEdit, + oneof: 'action', + }, + { + no: 5, + name: 'search', + kind: 'message', + T: ChatMessageActionSearch, + oneof: 'action', + }, + { + no: 2, + name: 'num_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'context_items', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + { + no: 6, + name: 'latest_intent', + kind: 'enum', + T: proto3.getEnumType(ChatIntentType), + }, + { no: 7, name: 'generation_stats', kind: 'message', T: ChatMetrics }, + { + no: 8, + name: 'knowledge_base_items', + kind: 'message', + T: KnowledgeBaseItemWithMetadata, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessageAction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessageAction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessageAction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessageAction, a, b); + } +}; +var ChatMessage = class _ChatMessage extends Message { + /** + * UID for each chat message. + * + * @generated from field: string message_id = 1; + */ + messageId = ''; + /** + * Where the message came from (ie. user, bot, system, etc.) + * + * @generated from field: exa.codeium_common_pb.ChatMessageSource source = 2; + */ + source = ChatMessageSource.UNSPECIFIED; + /** + * @generated from field: google.protobuf.Timestamp timestamp = 3; + */ + timestamp; + /** + * UID for the conversation the message came from. This indiciates + * the history that was sent to the server. + * + * @generated from field: string conversation_id = 4; + */ + conversationId = ''; + /** + * @generated from oneof exa.chat_pb.ChatMessage.content + */ + content = { case: void 0 }; + /** + * Whether or not the message is still being streamed out. + * + * @generated from field: bool in_progress = 9; + */ + inProgress = false; + /** + * Optional. Used for retrying when the chat produces an error. + * + * @generated from field: exa.chat_pb.GetChatMessageRequest request = 10; + */ + request; + /** + * Whether or not code blocks in the message should be redacted. + * + * @generated from field: bool redact = 11; + */ + redact = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessage'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'message_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'source', + kind: 'enum', + T: proto3.getEnumType(ChatMessageSource), + }, + { no: 3, name: 'timestamp', kind: 'message', T: Timestamp }, + { + no: 4, + name: 'conversation_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'intent', + kind: 'message', + T: ChatMessageIntent, + oneof: 'content', + }, + { + no: 6, + name: 'action', + kind: 'message', + T: ChatMessageAction, + oneof: 'content', + }, + { + no: 7, + name: 'error', + kind: 'message', + T: ChatMessageError, + oneof: 'content', + }, + { + no: 8, + name: 'status', + kind: 'message', + T: ChatMessageStatus, + oneof: 'content', + }, + { + no: 9, + name: 'in_progress', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 10, name: 'request', kind: 'message', T: GetChatMessageRequest }, + { + no: 11, + name: 'redact', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessage().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessage().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessage().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessage, a, b); + } +}; +var Conversation = class _Conversation extends Message { + /** + * @generated from field: repeated exa.chat_pb.ChatMessage messages = 1; + */ + messages = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.Conversation'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'messages', + kind: 'message', + T: ChatMessage, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _Conversation().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Conversation().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Conversation().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Conversation, a, b); + } +}; +var ChatMessagePrompt = class _ChatMessagePrompt extends Message { + /** + * @generated from field: string message_id = 1; + */ + messageId = ''; + /** + * @generated from field: exa.codeium_common_pb.ChatMessageSource source = 2; + */ + source = ChatMessageSource.UNSPECIFIED; + /** + * Constructed prompt (no metadata). + * + * @generated from field: string prompt = 3; + */ + prompt = ''; + /** + * @generated from field: uint32 num_tokens = 4; + */ + numTokens = 0; + /** + * @generated from field: bool safe_for_code_telemetry = 5; + */ + safeForCodeTelemetry = false; + /** + * Only applicable for CHAT_MESSAGE_SOURCE_SYSTEM and for OpenAI models. + * + * @generated from field: repeated exa.codeium_common_pb.ChatToolCall tool_calls = 6; + */ + toolCalls = []; + /** + * Only applicable for CHAT_MESSAGE_SOURCE_TOOL. + * + * @generated from field: string tool_call_id = 7; + */ + toolCallId = ''; + /** + * @generated from field: exa.chat_pb.PromptCacheOptions prompt_cache_options = 8; + */ + promptCacheOptions; + /** + * Only consumed by Anthropic. + * + * @generated from field: bool tool_result_is_error = 9; + */ + toolResultIsError = false; + /** + * Images are deprecated. Use media instead. + * + * @generated from field: repeated exa.codeium_common_pb.ImageData images = 10 [deprecated = true]; + * @deprecated + */ + images = []; + /** + * @generated from field: repeated exa.codeium_common_pb.Media media = 19; + */ + media = []; + /** + * Optional thinking text + * + * @generated from field: string thinking = 11; + */ + thinking = ''; + /** + * Deprecated: No need for this field anymore, just always circulate the + * thinking text and signature. + * + * @generated from field: string raw_thinking = 17 [deprecated = true]; + * @deprecated + */ + rawThinking = ''; + /** + * Signature of the thinking string. + * Deprecated. Use thinking_signature instead. + * + * @generated from field: string signature = 12 [deprecated = true]; + * @deprecated + */ + signature = ''; + /** + * @generated from field: bytes thinking_signature = 20; + */ + thinkingSignature = new Uint8Array(0); + /** + * Whether the thought is redacted. + * + * @generated from field: bool thinking_redacted = 13; + */ + thinkingRedacted = false; + /** + * Optional prompt annotated ranges used only for internal inference. + * Byte offsets are relative inside the prompt bytes. + * This is only for speculative copy right now. + * For prompt caching, we should use prompt_cache_options. + * + * @generated from field: repeated exa.codeium_common_pb.PromptAnnotationRange prompt_annotation_ranges = 14; + */ + promptAnnotationRanges = []; + /** + * @generated from field: int32 step_idx = 18; + */ + stepIdx = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessagePrompt'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'message_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'source', + kind: 'enum', + T: proto3.getEnumType(ChatMessageSource), + }, + { + no: 3, + name: 'prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'num_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'safe_for_code_telemetry', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'tool_calls', + kind: 'message', + T: ChatToolCall, + repeated: true, + }, + { + no: 7, + name: 'tool_call_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'prompt_cache_options', + kind: 'message', + T: PromptCacheOptions, + }, + { + no: 9, + name: 'tool_result_is_error', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 10, name: 'images', kind: 'message', T: ImageData, repeated: true }, + { no: 19, name: 'media', kind: 'message', T: Media, repeated: true }, + { + no: 11, + name: 'thinking', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 17, + name: 'raw_thinking', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'signature', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 20, + name: 'thinking_signature', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + { + no: 13, + name: 'thinking_redacted', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 14, + name: 'prompt_annotation_ranges', + kind: 'message', + T: PromptAnnotationRange, + repeated: true, + }, + { + no: 18, + name: 'step_idx', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessagePrompt().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessagePrompt().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessagePrompt().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessagePrompt, a, b); + } +}; +var ChatMessagePrompts = class _ChatMessagePrompts extends Message { + /** + * @generated from field: repeated exa.chat_pb.ChatMessagePrompt prompts = 1; + */ + prompts = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessagePrompts'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'prompts', + kind: 'message', + T: ChatMessagePrompt, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessagePrompts().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessagePrompts().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessagePrompts().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessagePrompts, a, b); + } +}; +var PromptCacheOptions = class _PromptCacheOptions extends Message { + /** + * @generated from field: exa.chat_pb.CacheControlType type = 1; + */ + type = CacheControlType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.PromptCacheOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(CacheControlType), + }, + ]); + static fromBinary(bytes, options) { + return new _PromptCacheOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptCacheOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptCacheOptions().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PromptCacheOptions, a, b); + } +}; +var ChatToolDefinition = class _ChatToolDefinition extends Message { + /** + * @generated from field: string name = 1; + */ + name = ''; + /** + * @generated from field: string description = 2; + */ + description = ''; + /** + * Should be convertible into json.RawMessage and interpreted as JSON Schema + * object. + * + * @generated from field: string json_schema_string = 3; + */ + jsonSchemaString = ''; + /** + * Forces structured outputs. Only applicable to OpenAI models including and + * later than MODEL_CHAT_GPT_4O_2024_08_06 Note that this limits the supported + * types in the JSON schema: + * https://platform.openai.com/docs/guides/structured-outputs/supported-types + * + * @generated from field: bool strict = 4; + */ + strict = false; + /** + * Field names to check for attribution. If empty, then this tool does not + * need to be checked for attribution. These must exactly match the field + * names in the JSON schema, and must map to string fields. + * + * @generated from field: repeated string attribution_field_names = 5; + */ + attributionFieldNames = []; + /** + * Name of the server if this is a MCP tool. + * + * @generated from field: string server_name = 6; + */ + serverName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatToolDefinition'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'json_schema_string', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'strict', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'attribution_field_names', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 6, + name: 'server_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatToolDefinition().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatToolDefinition().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatToolDefinition().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatToolDefinition, a, b); + } +}; +var ChatToolChoice = class _ChatToolChoice extends Message { + /** + * @generated from oneof exa.chat_pb.ChatToolChoice.choice + */ + choice = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatToolChoice'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'option_name', kind: 'scalar', T: 9, oneof: 'choice' }, + { no: 2, name: 'tool_name', kind: 'scalar', T: 9, oneof: 'choice' }, + ]); + static fromBinary(bytes, options) { + return new _ChatToolChoice().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatToolChoice().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatToolChoice().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatToolChoice, a, b); + } +}; +var ChatMentionsSearchRequest = class _ChatMentionsSearchRequest extends Message { + /** + * @generated from field: string query = 1; + */ + query = ''; + /** + * Filters on the types of code context items to search over. + * + * @generated from field: repeated exa.codeium_common_pb.CodeContextType allowed_types = 2; + */ + allowedTypes = []; + /** + * Whether to include repo info in the search results. + * + * @generated from field: bool include_repo_info = 3; + */ + includeRepoInfo = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMentionsSearchRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'allowed_types', + kind: 'enum', + T: proto3.getEnumType(CodeContextType), + repeated: true, + }, + { + no: 3, + name: 'include_repo_info', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMentionsSearchRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMentionsSearchRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMentionsSearchRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMentionsSearchRequest, a, b); + } +}; +var ChatMentionsSearchResponse = class _ChatMentionsSearchResponse extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem cci_items = 1; + */ + cciItems = []; + /** + * @generated from field: repeated exa.codeium_common_pb.GitRepoInfo repo_infos = 2; + */ + repoInfos = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMentionsSearchResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'cci_items', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + { + no: 2, + name: 'repo_infos', + kind: 'message', + T: GitRepoInfo, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMentionsSearchResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMentionsSearchResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMentionsSearchResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ChatMentionsSearchResponse, a, b); + } +}; +var GetChatMessageRequest = class _GetChatMessageRequest extends Message { + /** + * @generated from field: exa.codeium_common_pb.Metadata metadata = 1; + */ + metadata; + /** + * Chat messages in ascending order of timestamp. + * + * @generated from field: repeated exa.chat_pb.ChatMessage chat_messages = 3; + */ + chatMessages = []; + /** + * Context + * + * @generated from field: exa.codeium_common_pb.Document active_document = 5; + */ + activeDocument; + /** + * @generated from field: repeated string open_document_uris = 12; + */ + openDocumentUris = []; + /** + * @generated from field: repeated string workspace_uris = 13; + */ + workspaceUris = []; + /** + * Optional extra context + * + * @generated from field: string active_selection = 11; + */ + activeSelection = ''; + /** + * @generated from field: exa.codeium_common_pb.ContextInclusionType context_inclusion_type = 8; + */ + contextInclusionType = ContextInclusionType.UNSPECIFIED; + /** + * Desired model type to be used for the generation. + * + * @generated from field: exa.codeium_common_pb.Model chat_model = 9; + */ + chatModel = Model.UNSPECIFIED; + /** + * Override the system prompt, regardless of whether or not there is context. + * + * @generated from field: string system_prompt_override = 10; + */ + systemPromptOverride = ''; + /** + * @generated from field: string chat_model_name = 14; + */ + chatModelName = ''; + /** + * @generated from field: exa.chat_pb.GetChatMessageRequest.EnterpriseExternalModelConfig enterprise_chat_model_config = 15; + */ + enterpriseChatModelConfig; + /** + * @generated from field: exa.codeium_common_pb.ExperimentConfig experiment_config = 4 [deprecated = true]; + * @deprecated + */ + experimentConfig; + /** + * @generated from field: repeated string open_document_paths_migrate_me_to_uris = 6 [deprecated = true]; + * @deprecated + */ + openDocumentPathsMigrateMeToUris = []; + /** + * @generated from field: repeated string workspace_paths_migrate_me_to_uris = 7 [deprecated = true]; + * @deprecated + */ + workspacePathsMigrateMeToUris = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.GetChatMessageRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: Metadata }, + { + no: 3, + name: 'chat_messages', + kind: 'message', + T: ChatMessage, + repeated: true, + }, + { no: 5, name: 'active_document', kind: 'message', T: Document }, + { + no: 12, + name: 'open_document_uris', + kind: 'scalar', + T: 9, + repeated: true, + }, + { no: 13, name: 'workspace_uris', kind: 'scalar', T: 9, repeated: true }, + { + no: 11, + name: 'active_selection', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'context_inclusion_type', + kind: 'enum', + T: proto3.getEnumType(ContextInclusionType), + }, + { no: 9, name: 'chat_model', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 10, + name: 'system_prompt_override', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 14, + name: 'chat_model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 15, + name: 'enterprise_chat_model_config', + kind: 'message', + T: GetChatMessageRequest_EnterpriseExternalModelConfig, + }, + { no: 4, name: 'experiment_config', kind: 'message', T: ExperimentConfig }, + { + no: 6, + name: 'open_document_paths_migrate_me_to_uris', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 7, + name: 'workspace_paths_migrate_me_to_uris', + kind: 'scalar', + T: 9, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetChatMessageRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetChatMessageRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetChatMessageRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetChatMessageRequest, a, b); + } +}; +var GetChatMessageRequest_EnterpriseExternalModelConfig = class _GetChatMessageRequest_EnterpriseExternalModelConfig extends Message { + /** + * @generated from field: int32 max_output_tokens = 2; + */ + maxOutputTokens = 0; + /** + * @generated from field: int32 max_input_tokens = 3; + */ + maxInputTokens = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.chat_pb.GetChatMessageRequest.EnterpriseExternalModelConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 2, + name: 'max_output_tokens', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'max_input_tokens', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _GetChatMessageRequest_EnterpriseExternalModelConfig().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _GetChatMessageRequest_EnterpriseExternalModelConfig().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetChatMessageRequest_EnterpriseExternalModelConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals( + _GetChatMessageRequest_EnterpriseExternalModelConfig, + a, + b, + ); + } +}; +var ChatExperimentStatus = class _ChatExperimentStatus extends Message { + /** + * @generated from field: exa.codeium_common_pb.ExperimentKey experiment_key = 1; + */ + experimentKey = ExperimentKey.UNSPECIFIED; + /** + * @generated from field: bool enabled = 2; + */ + enabled = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatExperimentStatus'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'experiment_key', + kind: 'enum', + T: proto3.getEnumType(ExperimentKey), + }, + { + no: 2, + name: 'enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ChatExperimentStatus().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatExperimentStatus().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatExperimentStatus().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatExperimentStatus, a, b); + } +}; +var FormattedChatMessage = class _FormattedChatMessage extends Message { + /** + * @generated from field: exa.codeium_common_pb.ChatMessageSource role = 1; + */ + role = ChatMessageSource.UNSPECIFIED; + /** + * @generated from field: string header = 2; + */ + header = ''; + /** + * @generated from field: string content = 3; + */ + content = ''; + /** + * @generated from field: string footer = 4; + */ + footer = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.FormattedChatMessage'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'role', + kind: 'enum', + T: proto3.getEnumType(ChatMessageSource), + }, + { + no: 2, + name: 'header', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'footer', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _FormattedChatMessage().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FormattedChatMessage().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FormattedChatMessage().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FormattedChatMessage, a, b); + } +}; +var IndexMap = class _IndexMap extends Message { + /** + * @generated from field: map index_map = 1; + */ + indexMap = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.IndexMap'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'index_map', + kind: 'map', + K: 5, + V: { kind: 'message', T: IndexMap_IndexList }, + }, + ]); + static fromBinary(bytes, options) { + return new _IndexMap().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexMap().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexMap().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexMap, a, b); + } +}; +var IndexMap_IndexList = class _IndexMap_IndexList extends Message { + /** + * @generated from field: repeated int32 indices = 1; + */ + indices = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.IndexMap.IndexList'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'indices', kind: 'scalar', T: 5, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _IndexMap_IndexList().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexMap_IndexList().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexMap_IndexList().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexMap_IndexList, a, b); + } +}; +var ChatMessageRollout = class _ChatMessageRollout extends Message { + /** + * @generated from field: string system_prompt = 1; + */ + systemPrompt = ''; + /** + * @generated from field: repeated exa.chat_pb.ChatToolDefinition tools = 2; + */ + tools = []; + /** + * @generated from field: exa.chat_pb.ChatToolChoice tool_choice = 3; + */ + toolChoice; + /** + * @generated from field: repeated exa.chat_pb.ChatMessagePrompt input_chat_messages = 4; + */ + inputChatMessages = []; + /** + * @generated from field: repeated exa.chat_pb.ChatMessagePrompt output_chat_messages = 5; + */ + outputChatMessages = []; + /** + * Map from trajectory step index to chat message indices + * + * @generated from field: exa.chat_pb.IndexMap trajectory_to_chat_message_index_map = 6; + */ + trajectoryToChatMessageIndexMap; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.ChatMessageRollout'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'system_prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'tools', + kind: 'message', + T: ChatToolDefinition, + repeated: true, + }, + { no: 3, name: 'tool_choice', kind: 'message', T: ChatToolChoice }, + { + no: 4, + name: 'input_chat_messages', + kind: 'message', + T: ChatMessagePrompt, + repeated: true, + }, + { + no: 5, + name: 'output_chat_messages', + kind: 'message', + T: ChatMessagePrompt, + repeated: true, + }, + { + no: 6, + name: 'trajectory_to_chat_message_index_map', + kind: 'message', + T: IndexMap, + }, + ]); + static fromBinary(bytes, options) { + return new _ChatMessageRollout().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatMessageRollout().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatMessageRollout().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatMessageRollout, a, b); + } +}; +var XboxInferenceToolRequest = class _XboxInferenceToolRequest extends Message { + /** + * Model name from model.info object + * + * @generated from field: string model_name = 3; + */ + modelName = ''; + /** + * Codeium Model Enum, stringified + * + * @generated from field: string model_enum = 4; + */ + modelEnum = ''; + /** + * @generated from field: exa.chat_pb.Example gemini_example = 2; + */ + geminiExample; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.XboxInferenceToolRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 3, + name: 'model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'model_enum', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'gemini_example', kind: 'message', T: Example }, + ]); + static fromBinary(bytes, options) { + return new _XboxInferenceToolRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _XboxInferenceToolRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _XboxInferenceToolRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_XboxInferenceToolRequest, a, b); + } +}; +var Example = class _Example extends Message { + /** + * The messages that comprise the conversation + * + * @generated from field: repeated exa.chat_pb.Message messages = 1; + */ + messages = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.Example'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'messages', kind: 'message', T: Message2, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _Example().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Example().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Example().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Example, a, b); + } +}; +var Message2 = class _Message extends Message { + /** + * The role within the conversation, e.g., User, Assistant, System + * See go/gemini-proto-roles + * + * User, Assistant, System, ... + * + * @generated from field: string role = 1; + */ + role = ''; + /** + * Content of the message as a series of chunks. In the simplest case, + * could be a single chunk with a text value. + * + * @generated from field: repeated exa.chat_pb.Chunk chunks = 2; + */ + chunks = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.Message'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'role', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'chunks', kind: 'message', T: Chunk, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _Message().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Message().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Message().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Message, a, b); + } +}; +var Chunk = class _Chunk extends Message { + /** + * The main value of the chunk. One must be specified + * + * @generated from oneof exa.chat_pb.Chunk.value + */ + value = { case: void 0 }; + /** + * Whether to defer to the formatter to infer trainable masking, or to + * override explicitly. See go/gemini-proto-trainable + * + * @generated from field: exa.chat_pb.Chunk.Trainable trainable = 10; + */ + trainable = Chunk_Trainable.UNKNOWN_TRAINABLE; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.Chunk'; + static fields = proto3.util.newFieldList(() => [ + { no: 3, name: 'text', kind: 'scalar', T: 9, oneof: 'value' }, + { no: 4, name: 'image', kind: 'message', T: Image, oneof: 'value' }, + { + no: 10, + name: 'trainable', + kind: 'enum', + T: proto3.getEnumType(Chunk_Trainable), + }, + ]); + static fromBinary(bytes, options) { + return new _Chunk().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Chunk().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Chunk().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Chunk, a, b); + } +}; +var Chunk_Trainable; +(function (Chunk_Trainable2) { + Chunk_Trainable2[(Chunk_Trainable2['UNKNOWN_TRAINABLE'] = 0)] = + 'UNKNOWN_TRAINABLE'; + Chunk_Trainable2[(Chunk_Trainable2['FORMATTER_DEFINED'] = 1)] = + 'FORMATTER_DEFINED'; + Chunk_Trainable2[(Chunk_Trainable2['ALWAYS'] = 2)] = 'ALWAYS'; + Chunk_Trainable2[(Chunk_Trainable2['NEVER'] = 3)] = 'NEVER'; +})(Chunk_Trainable || (Chunk_Trainable = {})); +proto3.util.setEnumType(Chunk_Trainable, 'exa.chat_pb.Chunk.Trainable', [ + { no: 0, name: 'UNKNOWN_TRAINABLE' }, + { no: 1, name: 'FORMATTER_DEFINED' }, + { no: 2, name: 'ALWAYS' }, + { no: 3, name: 'NEVER' }, +]); +var Image = class _Image extends Message { + /** + * value has ID 5 for backwards compat with gemini.rl.Image. IDs 1-4 are + * available. + * + * @generated from field: exa.chat_pb.FileData value = 5; + */ + value; + /** + * Best effort, may not be present. Can be used to compute how many tokens + * would be needed for this image. + * + * @generated from field: int32 height_px = 3; + */ + heightPx = 0; + /** + * @generated from field: int32 width_px = 4; + */ + widthPx = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.Image'; + static fields = proto3.util.newFieldList(() => [ + { no: 5, name: 'value', kind: 'message', T: FileData }, + { + no: 3, + name: 'height_px', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'width_px', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _Image().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Image().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Image().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Image, a, b); + } +}; +var FileData = class _FileData extends Message { + /** + * The actual bytes of the file + * + * @generated from field: bytes content = 3; + */ + content = new Uint8Array(0); + /** + * Pointers to a location of the file, as an alternate to the full value + * string location = 1; + * + * @generated from field: string mime_type = 2; + */ + mimeType = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.FileData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 3, + name: 'content', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + { + no: 2, + name: 'mime_type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _FileData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FileData, a, b); + } +}; +var RpcRequest = class _RpcRequest extends Message { + /** + * @generated from oneof exa.chat_pb.RpcRequest.request + */ + request = { case: void 0 }; + /** + * Unique identifier for this RPC, used to track asynchronous requests. + * + * This field should be left empty. It will be assigned a unique value during + * RPC execution. Any existing value will be overwritten. + * + * @generated from field: string id = 3; + */ + id = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.RpcRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'run_tool_request', + kind: 'message', + T: RunToolRequest, + oneof: 'request', + }, + { + no: 3, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _RpcRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RpcRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RpcRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RpcRequest, a, b); + } +}; +var RpcResponse = class _RpcResponse extends Message { + /** + * @generated from oneof exa.chat_pb.RpcResponse.response + */ + response = { case: void 0 }; + /** + * The id of the original RpcRequest. + * + * @generated from field: string request_id = 2; + */ + requestId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.RpcResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'run_tool_response', + kind: 'message', + T: RunToolResponse, + oneof: 'response', + }, + { + no: 2, + name: 'request_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _RpcResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RpcResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RpcResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RpcResponse, a, b); + } +}; +var RunToolRequest = class _RunToolRequest extends Message { + /** + * Tool Name. + * + * Ex: + * name: "FlightService" + * + * REQUIRED + * + * @generated from field: string name = 1; + */ + name = ''; + /** + * One tool can support multiple operations/methods. `operation_id` clarifies + * the exact method to use. + * + * Ex: + * operation_id: SearchFlight + * + * REQUIRED + * + * @generated from field: string operation_id = 2; + */ + operationId = ''; + /** + * Parameters to be supplied to the tool method. These must be conformant with + * tool's manifest/OpenAPI spec. + * + * Leaving it as a string, to keep the format flexible. + * + * Ex: + * {origin: "SFO", destination = "LAX", date = "2023-01-01"} + * + * REQUIRED + * + * @generated from field: string parameters = 3; + */ + parameters = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.RunToolRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'operation_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'parameters', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _RunToolRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RunToolRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RunToolRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RunToolRequest, a, b); + } +}; +var RunToolResponse = class _RunToolResponse extends Message { + /** + * @generated from field: string response = 1; + */ + response = ''; + /** + * @generated from field: exa.chat_pb.RunToolResponse.Status status = 2; + */ + status; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.RunToolResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'response', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'status', kind: 'message', T: RunToolResponse_Status }, + ]); + static fromBinary(bytes, options) { + return new _RunToolResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RunToolResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RunToolResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RunToolResponse, a, b); + } +}; +var RunToolResponse_Status = class _RunToolResponse_Status extends Message { + /** + * @generated from field: int32 code = 1; + */ + code = 0; + /** + * A developer-facing status message. + * + * @generated from field: string status_message = 2; + */ + statusMessage = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_pb.RunToolResponse.Status'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'code', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'status_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _RunToolResponse_Status().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RunToolResponse_Status().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RunToolResponse_Status().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RunToolResponse_Status, a, b); + } +}; + +// exa/proto_ts/dist/exa/context_module_pb/context_module_pb.js +var ContextChangeType; +(function (ContextChangeType2) { + ContextChangeType2[(ContextChangeType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ContextChangeType2[(ContextChangeType2['ACTIVE_DOCUMENT'] = 1)] = + 'ACTIVE_DOCUMENT'; + ContextChangeType2[(ContextChangeType2['CURSOR_POSITION'] = 2)] = + 'CURSOR_POSITION'; + ContextChangeType2[(ContextChangeType2['CHAT_MESSAGE_RECEIVED'] = 3)] = + 'CHAT_MESSAGE_RECEIVED'; + ContextChangeType2[(ContextChangeType2['OPEN_DOCUMENTS'] = 4)] = + 'OPEN_DOCUMENTS'; + ContextChangeType2[(ContextChangeType2['ORACLE_ITEMS'] = 5)] = 'ORACLE_ITEMS'; + ContextChangeType2[(ContextChangeType2['PINNED_CONTEXT'] = 6)] = + 'PINNED_CONTEXT'; + ContextChangeType2[(ContextChangeType2['PINNED_GUIDELINE'] = 7)] = + 'PINNED_GUIDELINE'; + ContextChangeType2[(ContextChangeType2['ACTIVE_NODE'] = 9)] = 'ACTIVE_NODE'; +})(ContextChangeType || (ContextChangeType = {})); +proto3.util.setEnumType( + ContextChangeType, + 'exa.context_module_pb.ContextChangeType', + [ + { no: 0, name: 'CONTEXT_CHANGE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CONTEXT_CHANGE_TYPE_ACTIVE_DOCUMENT' }, + { no: 2, name: 'CONTEXT_CHANGE_TYPE_CURSOR_POSITION' }, + { no: 3, name: 'CONTEXT_CHANGE_TYPE_CHAT_MESSAGE_RECEIVED' }, + { no: 4, name: 'CONTEXT_CHANGE_TYPE_OPEN_DOCUMENTS' }, + { no: 5, name: 'CONTEXT_CHANGE_TYPE_ORACLE_ITEMS' }, + { no: 6, name: 'CONTEXT_CHANGE_TYPE_PINNED_CONTEXT' }, + { no: 7, name: 'CONTEXT_CHANGE_TYPE_PINNED_GUIDELINE' }, + { no: 9, name: 'CONTEXT_CHANGE_TYPE_ACTIVE_NODE' }, + ], +); +var ContextUseCase; +(function (ContextUseCase2) { + ContextUseCase2[(ContextUseCase2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ContextUseCase2[(ContextUseCase2['AUTOCOMPLETE'] = 1)] = 'AUTOCOMPLETE'; + ContextUseCase2[(ContextUseCase2['CHAT'] = 2)] = 'CHAT'; + ContextUseCase2[(ContextUseCase2['CHAT_COMPLETION'] = 3)] = 'CHAT_COMPLETION'; + ContextUseCase2[(ContextUseCase2['CORTEX_RESEARCH'] = 4)] = 'CORTEX_RESEARCH'; + ContextUseCase2[(ContextUseCase2['EVAL'] = 5)] = 'EVAL'; + ContextUseCase2[(ContextUseCase2['CHAT_COMPLETION_GENERATE'] = 6)] = + 'CHAT_COMPLETION_GENERATE'; + ContextUseCase2[(ContextUseCase2['SUPERCOMPLETE'] = 7)] = 'SUPERCOMPLETE'; + ContextUseCase2[(ContextUseCase2['FAST_APPLY'] = 8)] = 'FAST_APPLY'; + ContextUseCase2[(ContextUseCase2['COMMAND_TERMINAL'] = 9)] = + 'COMMAND_TERMINAL'; +})(ContextUseCase || (ContextUseCase = {})); +proto3.util.setEnumType( + ContextUseCase, + 'exa.context_module_pb.ContextUseCase', + [ + { no: 0, name: 'CONTEXT_USE_CASE_UNSPECIFIED' }, + { no: 1, name: 'CONTEXT_USE_CASE_AUTOCOMPLETE' }, + { no: 2, name: 'CONTEXT_USE_CASE_CHAT' }, + { no: 3, name: 'CONTEXT_USE_CASE_CHAT_COMPLETION' }, + { no: 4, name: 'CONTEXT_USE_CASE_CORTEX_RESEARCH' }, + { no: 5, name: 'CONTEXT_USE_CASE_EVAL' }, + { no: 6, name: 'CONTEXT_USE_CASE_CHAT_COMPLETION_GENERATE' }, + { no: 7, name: 'CONTEXT_USE_CASE_SUPERCOMPLETE' }, + { no: 8, name: 'CONTEXT_USE_CASE_FAST_APPLY' }, + { no: 9, name: 'CONTEXT_USE_CASE_COMMAND_TERMINAL' }, + ], +); +var ContextRefreshReason; +(function (ContextRefreshReason2) { + ContextRefreshReason2[(ContextRefreshReason2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + ContextRefreshReason2[(ContextRefreshReason2['AUTOCOMPLETE'] = 1)] = + 'AUTOCOMPLETE'; + ContextRefreshReason2[(ContextRefreshReason2['CHAT'] = 2)] = 'CHAT'; + ContextRefreshReason2[(ContextRefreshReason2['IDE_ACTION'] = 4)] = + 'IDE_ACTION'; + ContextRefreshReason2[(ContextRefreshReason2['CHAT_COMPLETION'] = 5)] = + 'CHAT_COMPLETION'; +})(ContextRefreshReason || (ContextRefreshReason = {})); +proto3.util.setEnumType( + ContextRefreshReason, + 'exa.context_module_pb.ContextRefreshReason', + [ + { no: 0, name: 'CONTEXT_REFRESH_REASON_UNSPECIFIED' }, + { no: 1, name: 'CONTEXT_REFRESH_REASON_AUTOCOMPLETE' }, + { no: 2, name: 'CONTEXT_REFRESH_REASON_CHAT' }, + { no: 4, name: 'CONTEXT_REFRESH_REASON_IDE_ACTION' }, + { no: 5, name: 'CONTEXT_REFRESH_REASON_CHAT_COMPLETION' }, + ], +); +var ContextChangeEvent = class _ContextChangeEvent extends Message { + /** + * @generated from oneof exa.context_module_pb.ContextChangeEvent.context_change_event + */ + contextChangeEvent = { case: void 0 }; + /** + * @generated from field: exa.context_module_pb.ContextRefreshReason context_refresh_reason = 6; + */ + contextRefreshReason = ContextRefreshReason.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextChangeEvent'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'context_change_active_document', + kind: 'message', + T: ContextChangeActiveDocument, + oneof: 'context_change_event', + }, + { + no: 2, + name: 'context_change_cursor_position', + kind: 'message', + T: ContextChangeCursorPosition, + oneof: 'context_change_event', + }, + { + no: 3, + name: 'context_change_chat_message_received', + kind: 'message', + T: ContextChangeChatMessageReceived, + oneof: 'context_change_event', + }, + { + no: 4, + name: 'context_change_open_documents', + kind: 'message', + T: ContextChangeOpenDocuments, + oneof: 'context_change_event', + }, + { + no: 5, + name: 'context_change_oracle_items', + kind: 'message', + T: ContextChangeOracleItems, + oneof: 'context_change_event', + }, + { + no: 7, + name: 'context_change_pinned_context', + kind: 'message', + T: ContextChangePinnedContext, + oneof: 'context_change_event', + }, + { + no: 8, + name: 'context_change_pinned_guideline', + kind: 'message', + T: ContextChangePinnedGuideline, + oneof: 'context_change_event', + }, + { + no: 10, + name: 'context_change_active_node', + kind: 'message', + T: ContextChangeActiveNode, + oneof: 'context_change_event', + }, + { + no: 6, + name: 'context_refresh_reason', + kind: 'enum', + T: proto3.getEnumType(ContextRefreshReason), + }, + ]); + static fromBinary(bytes, options) { + return new _ContextChangeEvent().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextChangeEvent().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextChangeEvent().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ContextChangeEvent, a, b); + } +}; +var ContextChangeActiveDocument = class _ContextChangeActiveDocument extends Message { + /** + * @generated from field: exa.codeium_common_pb.Document document = 1; + */ + document; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextChangeActiveDocument'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'document', kind: 'message', T: Document }, + ]); + static fromBinary(bytes, options) { + return new _ContextChangeActiveDocument().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextChangeActiveDocument().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextChangeActiveDocument().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ContextChangeActiveDocument, a, b); + } +}; +var ContextChangeCursorPosition = class _ContextChangeCursorPosition extends Message { + /** + * Includes DocumentPosition + * + * @generated from field: exa.codeium_common_pb.Document document = 2; + */ + document; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextChangeCursorPosition'; + static fields = proto3.util.newFieldList(() => [ + { no: 2, name: 'document', kind: 'message', T: Document }, + ]); + static fromBinary(bytes, options) { + return new _ContextChangeCursorPosition().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextChangeCursorPosition().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextChangeCursorPosition().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ContextChangeCursorPosition, a, b); + } +}; +var ContextChangeChatMessageReceived = class _ContextChangeChatMessageReceived extends Message { + /** + * @generated from field: repeated exa.chat_pb.ChatMessage chat_messages = 1; + */ + chatMessages = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextChangeChatMessageReceived'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'chat_messages', + kind: 'message', + T: ChatMessage, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ContextChangeChatMessageReceived().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextChangeChatMessageReceived().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextChangeChatMessageReceived().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ContextChangeChatMessageReceived, a, b); + } +}; +var ContextChangeOpenDocuments = class _ContextChangeOpenDocuments extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.Document other_open_documents = 1; + */ + otherOpenDocuments = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextChangeOpenDocuments'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'other_open_documents', + kind: 'message', + T: Document, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ContextChangeOpenDocuments().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextChangeOpenDocuments().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextChangeOpenDocuments().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ContextChangeOpenDocuments, a, b); + } +}; +var ContextChangeOracleItems = class _ContextChangeOracleItems extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem oracle_items = 1; + */ + oracleItems = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextChangeOracleItems'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'oracle_items', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ContextChangeOracleItems().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextChangeOracleItems().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextChangeOracleItems().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ContextChangeOracleItems, a, b); + } +}; +var ContextChangePinnedContext = class _ContextChangePinnedContext extends Message { + /** + * @generated from oneof exa.context_module_pb.ContextChangePinnedContext.scope + */ + scope = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextChangePinnedContext'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'pinned_scope', + kind: 'message', + T: ContextScope, + oneof: 'scope', + }, + { + no: 2, + name: 'mentioned_scope', + kind: 'message', + T: ContextScope, + oneof: 'scope', + }, + ]); + static fromBinary(bytes, options) { + return new _ContextChangePinnedContext().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextChangePinnedContext().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextChangePinnedContext().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ContextChangePinnedContext, a, b); + } +}; +var ContextChangePinnedGuideline = class _ContextChangePinnedGuideline extends Message { + /** + * @generated from field: exa.codeium_common_pb.Guideline guideline = 1; + */ + guideline; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextChangePinnedGuideline'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'guideline', kind: 'message', T: Guideline }, + ]); + static fromBinary(bytes, options) { + return new _ContextChangePinnedGuideline().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextChangePinnedGuideline().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextChangePinnedGuideline().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ContextChangePinnedGuideline, a, b); + } +}; +var ContextChangeActiveNode = class _ContextChangeActiveNode extends Message { + /** + * @generated from field: exa.codeium_common_pb.CodeContextItem active_node = 1; + */ + activeNode; + /** + * @generated from field: exa.codeium_common_pb.Document document = 2; + */ + document; + /** + * May be false if a change event was forcibly created even without an actual + * node change. + * + * @generated from field: bool actual_node_change = 3; + */ + actualNodeChange = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextChangeActiveNode'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'active_node', kind: 'message', T: CodeContextItem }, + { no: 2, name: 'document', kind: 'message', T: Document }, + { + no: 3, + name: 'actual_node_change', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ContextChangeActiveNode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextChangeActiveNode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextChangeActiveNode().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ContextChangeActiveNode, a, b); + } +}; +var RetrievedCodeContextItemMetadata = class _RetrievedCodeContextItemMetadata extends Message { + /** + * Which source(s) this context info came from. + * + * @generated from field: repeated exa.codeium_common_pb.CodeContextSource context_sources = 1; + */ + contextSources = []; + /** + * The type of the context item. + * + * @generated from field: exa.codeium_common_pb.CodeContextType context_type = 2; + */ + contextType = CodeContextType.UNSPECIFIED; + /** + * The scorer that was used to rank and retrieve this context. + * + * @generated from field: string scorer = 3; + */ + scorer = ''; + /** + * The score of this item given by that scorer. + * + * @generated from field: float score = 4; + */ + score = 0; + /** + * Map from source string name to provided metadata if it exists. + * + * @generated from field: map provider_metadata = 5; + */ + providerMetadata = {}; + /** + * Whether code context item comes from user's manually mentioned or pinned + * context scopes. In this case, we should up-weight its importance. + * + * @generated from field: bool is_in_pinned_scope = 6; + */ + isInPinnedScope = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.RetrievedCodeContextItemMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'context_sources', + kind: 'enum', + T: proto3.getEnumType(CodeContextSource), + repeated: true, + }, + { + no: 2, + name: 'context_type', + kind: 'enum', + T: proto3.getEnumType(CodeContextType), + }, + { + no: 3, + name: 'scorer', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'score', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 5, + name: 'provider_metadata', + kind: 'map', + K: 9, + V: { kind: 'message', T: CodeContextProviderMetadata }, + }, + { + no: 6, + name: 'is_in_pinned_scope', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _RetrievedCodeContextItemMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RetrievedCodeContextItemMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RetrievedCodeContextItemMetadata().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_RetrievedCodeContextItemMetadata, a, b); + } +}; +var CciWithSubrangeWithRetrievalMetadata = class _CciWithSubrangeWithRetrievalMetadata extends Message { + /** + * @generated from field: exa.codeium_common_pb.CciWithSubrange cci_with_subrange = 1; + */ + cciWithSubrange; + /** + * @generated from field: exa.context_module_pb.RetrievedCodeContextItemMetadata metadata = 2; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.context_module_pb.CciWithSubrangeWithRetrievalMetadata'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'cci_with_subrange', kind: 'message', T: CciWithSubrange }, + { + no: 2, + name: 'metadata', + kind: 'message', + T: RetrievedCodeContextItemMetadata, + }, + ]); + static fromBinary(bytes, options) { + return new _CciWithSubrangeWithRetrievalMetadata().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CciWithSubrangeWithRetrievalMetadata().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CciWithSubrangeWithRetrievalMetadata().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CciWithSubrangeWithRetrievalMetadata, a, b); + } +}; +var CodeContextItemWithRetrievalMetadata = class _CodeContextItemWithRetrievalMetadata extends Message { + /** + * @generated from field: exa.codeium_common_pb.CodeContextItem code_context_item = 1; + */ + codeContextItem; + /** + * @generated from field: exa.context_module_pb.RetrievedCodeContextItemMetadata metadata = 2; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.context_module_pb.CodeContextItemWithRetrievalMetadata'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'code_context_item', kind: 'message', T: CodeContextItem }, + { + no: 2, + name: 'metadata', + kind: 'message', + T: RetrievedCodeContextItemMetadata, + }, + ]); + static fromBinary(bytes, options) { + return new _CodeContextItemWithRetrievalMetadata().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CodeContextItemWithRetrievalMetadata().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CodeContextItemWithRetrievalMetadata().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CodeContextItemWithRetrievalMetadata, a, b); + } +}; +var FileNameWithRetrievalMetadata = class _FileNameWithRetrievalMetadata extends Message { + /** + * @generated from field: string absolute_uri = 1; + */ + absoluteUri = ''; + /** + * TODO(rmalde) rename this type to be + * RetrievedContextItemMetadata so it's not specific to CCI's + * + * @generated from field: exa.context_module_pb.RetrievedCodeContextItemMetadata metadata = 2; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.FileNameWithRetrievalMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'metadata', + kind: 'message', + T: RetrievedCodeContextItemMetadata, + }, + ]); + static fromBinary(bytes, options) { + return new _FileNameWithRetrievalMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileNameWithRetrievalMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileNameWithRetrievalMetadata().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_FileNameWithRetrievalMetadata, a, b); + } +}; +var CodeContextProviderMetadata = class _CodeContextProviderMetadata extends Message { + /** + * Relative weight of this context item as compared to other ones discovered + * by the same code context source. Should be between (0, 1]. + * + * @generated from field: float relative_weight = 1; + */ + relativeWeight = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.CodeContextProviderMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'relative_weight', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + ]); + static fromBinary(bytes, options) { + return new _CodeContextProviderMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeContextProviderMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeContextProviderMetadata().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CodeContextProviderMetadata, a, b); + } +}; +var ContextModuleStats = class _ContextModuleStats extends Message { + /** + * @generated from field: exa.context_module_pb.ContextModuleStateStats context_module_state_stats = 1; + */ + contextModuleStateStats; + /** + * @generated from field: exa.context_module_pb.CodeContextItemIndexStats code_context_item_index_stats = 2; + */ + codeContextItemIndexStats; + /** + * @generated from field: int64 get_stats_latency_ms = 3; + */ + getStatsLatencyMs = protoInt64.zero; + /** + * @generated from field: int64 context_module_age_s = 4; + */ + contextModuleAgeS = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextModuleStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'context_module_state_stats', + kind: 'message', + T: ContextModuleStateStats, + }, + { + no: 2, + name: 'code_context_item_index_stats', + kind: 'message', + T: CodeContextItemIndexStats, + }, + { + no: 3, + name: 'get_stats_latency_ms', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 4, + name: 'context_module_age_s', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ContextModuleStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextModuleStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextModuleStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ContextModuleStats, a, b); + } +}; +var ContextModuleStateStats = class _ContextModuleStateStats extends Message { + /** + * @generated from field: int64 cci_per_source_bytes = 1; + */ + cciPerSourceBytes = protoInt64.zero; + /** + * @generated from field: int64 active_document_bytes = 2; + */ + activeDocumentBytes = protoInt64.zero; + /** + * @generated from field: int64 other_open_documents_bytes = 3; + */ + otherOpenDocumentsBytes = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextModuleStateStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'cci_per_source_bytes', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 2, + name: 'active_document_bytes', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 3, + name: 'other_open_documents_bytes', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ContextModuleStateStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextModuleStateStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextModuleStateStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ContextModuleStateStats, a, b); + } +}; +var CodeContextItemIndexStats = class _CodeContextItemIndexStats extends Message { + /** + * Total memory footprint of the CCIs stored in the index. + * + * @generated from field: int64 all_ccis_bytes = 1; + */ + allCcisBytes = protoInt64.zero; + /** + * Total number of CCIs stored in the index. + * + * @generated from field: int64 num_ccis_tracked = 2; + */ + numCcisTracked = protoInt64.zero; + /** + * Memory footprint of the TF Map excluding the CCIs themselves. + * + * @generated from field: int64 term_frequency_map_bytes = 3; + */ + termFrequencyMapBytes = protoInt64.zero; + /** + * Number of "terms" tracked in the TF map + * + * @generated from field: int64 num_terms_tracked = 4; + */ + numTermsTracked = protoInt64.zero; + /** + * Memory footprint of the file to CCI map excluding the CCIs. + * + * @generated from field: int64 file_to_cci_map_bytes = 5; + */ + fileToCciMapBytes = protoInt64.zero; + /** + * @generated from field: int64 num_files_tracked = 6; + */ + numFilesTracked = protoInt64.zero; + /** + * Last modified and HashSum tracker footprints. + * + * @generated from field: int64 last_modified_bytes = 7; + */ + lastModifiedBytes = protoInt64.zero; + /** + * @generated from field: int64 hash_map_bytes = 8; + */ + hashMapBytes = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.CodeContextItemIndexStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'all_ccis_bytes', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 2, + name: 'num_ccis_tracked', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 3, + name: 'term_frequency_map_bytes', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 4, + name: 'num_terms_tracked', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 5, + name: 'file_to_cci_map_bytes', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 6, + name: 'num_files_tracked', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 7, + name: 'last_modified_bytes', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 8, + name: 'hash_map_bytes', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CodeContextItemIndexStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeContextItemIndexStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeContextItemIndexStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeContextItemIndexStats, a, b); + } +}; +var PersistentContextModuleState = class _PersistentContextModuleState extends Message { + /** + * @generated from field: exa.codeium_common_pb.Guideline pinned_guideline = 1; + */ + pinnedGuideline; + /** + * @generated from field: exa.codeium_common_pb.ContextScope pinned_context_scope = 2; + */ + pinnedContextScope; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.PersistentContextModuleState'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'pinned_guideline', kind: 'message', T: Guideline }, + { no: 2, name: 'pinned_context_scope', kind: 'message', T: ContextScope }, + ]); + static fromBinary(bytes, options) { + return new _PersistentContextModuleState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PersistentContextModuleState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PersistentContextModuleState().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_PersistentContextModuleState, a, b); + } +}; +var ContextModuleResult = class _ContextModuleResult extends Message { + /** + * @generated from field: repeated exa.context_module_pb.CciWithSubrangeWithRetrievalMetadata retrieved_cci_with_subranges = 1; + */ + retrievedCciWithSubranges = []; + /** + * @generated from field: exa.codeium_common_pb.Document active_document = 2; + */ + activeDocument; + /** + * @generated from field: exa.codeium_common_pb.DocumentOutline active_document_outline = 5; + */ + activeDocumentOutline; + /** + * @generated from field: exa.context_module_pb.LocalNodeState local_node_state = 3; + */ + localNodeState; + /** + * @generated from field: exa.codeium_common_pb.Guideline guideline = 4; + */ + guideline; + /** + * @generated from field: repeated exa.codeium_common_pb.Document open_documents = 6; + */ + openDocuments = []; + /** + * @generated from field: repeated exa.codeium_common_pb.TerminalShellCommand running_terminal_commands = 8; + */ + runningTerminalCommands = []; + /** + * @generated from field: exa.codeium_common_pb.BrowserStateSnapshot browser_state_snapshot = 9; + */ + browserStateSnapshot; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.ContextModuleResult'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'retrieved_cci_with_subranges', + kind: 'message', + T: CciWithSubrangeWithRetrievalMetadata, + repeated: true, + }, + { no: 2, name: 'active_document', kind: 'message', T: Document }, + { + no: 5, + name: 'active_document_outline', + kind: 'message', + T: DocumentOutline, + }, + { no: 3, name: 'local_node_state', kind: 'message', T: LocalNodeState }, + { no: 4, name: 'guideline', kind: 'message', T: Guideline }, + { + no: 6, + name: 'open_documents', + kind: 'message', + T: Document, + repeated: true, + }, + { + no: 8, + name: 'running_terminal_commands', + kind: 'message', + T: TerminalShellCommand, + repeated: true, + }, + { + no: 9, + name: 'browser_state_snapshot', + kind: 'message', + T: BrowserStateSnapshot, + }, + ]); + static fromBinary(bytes, options) { + return new _ContextModuleResult().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextModuleResult().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextModuleResult().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ContextModuleResult, a, b); + } +}; +var LocalNodeState = class _LocalNodeState extends Message { + /** + * @generated from field: exa.codeium_common_pb.CodeContextItem current_node = 1; + */ + currentNode; + /** + * @generated from field: exa.codeium_common_pb.CodeContextItem closest_above_node = 2; + */ + closestAboveNode; + /** + * @generated from field: exa.codeium_common_pb.CodeContextItem closest_below_node = 3; + */ + closestBelowNode; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.context_module_pb.LocalNodeState'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'current_node', kind: 'message', T: CodeContextItem }, + { no: 2, name: 'closest_above_node', kind: 'message', T: CodeContextItem }, + { no: 3, name: 'closest_below_node', kind: 'message', T: CodeContextItem }, + ]); + static fromBinary(bytes, options) { + return new _LocalNodeState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LocalNodeState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LocalNodeState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LocalNodeState, a, b); + } +}; + +// exa/proto_ts/dist/exa/chat_client_server_pb/chat_client_server_pb.js +var ChatClientRequestStreamClientType; +(function (ChatClientRequestStreamClientType2) { + ChatClientRequestStreamClientType2[ + (ChatClientRequestStreamClientType2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + ChatClientRequestStreamClientType2[ + (ChatClientRequestStreamClientType2['IDE'] = 1) + ] = 'IDE'; + ChatClientRequestStreamClientType2[ + (ChatClientRequestStreamClientType2['BROWSER'] = 2) + ] = 'BROWSER'; +})( + ChatClientRequestStreamClientType || (ChatClientRequestStreamClientType = {}), +); +proto3.util.setEnumType( + ChatClientRequestStreamClientType, + 'exa.chat_client_server_pb.ChatClientRequestStreamClientType', + [ + { no: 0, name: 'CHAT_CLIENT_REQUEST_STREAM_CLIENT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CHAT_CLIENT_REQUEST_STREAM_CLIENT_TYPE_IDE' }, + { no: 2, name: 'CHAT_CLIENT_REQUEST_STREAM_CLIENT_TYPE_BROWSER' }, + ], +); +var StartChatClientRequestStreamRequest = class _StartChatClientRequestStreamRequest extends Message { + /** + * @generated from field: exa.chat_client_server_pb.ChatClientRequestStreamClientType client_type = 1; + */ + clientType = ChatClientRequestStreamClientType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.chat_client_server_pb.StartChatClientRequestStreamRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'client_type', + kind: 'enum', + T: proto3.getEnumType(ChatClientRequestStreamClientType), + }, + ]); + static fromBinary(bytes, options) { + return new _StartChatClientRequestStreamRequest().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _StartChatClientRequestStreamRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _StartChatClientRequestStreamRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_StartChatClientRequestStreamRequest, a, b); + } +}; +var ChatClientRequest = class _ChatClientRequest extends Message { + /** + * @generated from oneof exa.chat_client_server_pb.ChatClientRequest.request + */ + request = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_client_server_pb.ChatClientRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'add_cascade_input', + kind: 'message', + T: AddCascadeInputRequest, + oneof: 'request', + }, + { + no: 2, + name: 'send_action_to_chat_panel', + kind: 'message', + T: SendActionToChatPanelRequest, + oneof: 'request', + }, + { + no: 3, + name: 'initial_ack', + kind: 'message', + T: InitialAckRequest, + oneof: 'request', + }, + { + no: 4, + name: 'refresh_customization', + kind: 'message', + T: RefreshCustomizationRequest, + oneof: 'request', + }, + ]); + static fromBinary(bytes, options) { + return new _ChatClientRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatClientRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatClientRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatClientRequest, a, b); + } +}; +var AddCascadeInputRequest = class _AddCascadeInputRequest extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.TextOrScopeItem items = 1; + */ + items = []; + /** + * Deprecated: Use media instead + * + * @generated from field: repeated exa.codeium_common_pb.ImageData images = 2 [deprecated = true]; + * @deprecated + */ + images = []; + /** + * Optional media to include with the message + * + * @generated from field: repeated exa.codeium_common_pb.Media media = 3; + */ + media = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_client_server_pb.AddCascadeInputRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'items', + kind: 'message', + T: TextOrScopeItem, + repeated: true, + }, + { no: 2, name: 'images', kind: 'message', T: ImageData, repeated: true }, + { no: 3, name: 'media', kind: 'message', T: Media, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _AddCascadeInputRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AddCascadeInputRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AddCascadeInputRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AddCascadeInputRequest, a, b); + } +}; +var SendActionToChatPanelRequest = class _SendActionToChatPanelRequest extends Message { + /** + * The action type (e.g. FileMention, CodeBlockMention, setCascadeId, etc.) + * + * @generated from field: string action_type = 1; + */ + actionType = ''; + /** + * The serialized payload for the action + * + * @generated from field: repeated bytes payload = 2; + */ + payload = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_client_server_pb.SendActionToChatPanelRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'action_type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'payload', kind: 'scalar', T: 12, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _SendActionToChatPanelRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SendActionToChatPanelRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SendActionToChatPanelRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_SendActionToChatPanelRequest, a, b); + } +}; +var InitialAckRequest = class _InitialAckRequest extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_client_server_pb.InitialAckRequest'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _InitialAckRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _InitialAckRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _InitialAckRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_InitialAckRequest, a, b); + } +}; +var RefreshCustomizationRequest = class _RefreshCustomizationRequest extends Message { + /** + * @generated from field: exa.codeium_common_pb.RefreshCustomizationType config_type = 1; + */ + configType = RefreshCustomizationType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.chat_client_server_pb.RefreshCustomizationRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'config_type', + kind: 'enum', + T: proto3.getEnumType(RefreshCustomizationType), + }, + ]); + static fromBinary(bytes, options) { + return new _RefreshCustomizationRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RefreshCustomizationRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RefreshCustomizationRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_RefreshCustomizationRequest, a, b); + } +}; + +// exa/proto_ts/dist/exa/index_pb/index_pb.js +var IndexMode; +(function (IndexMode2) { + IndexMode2[(IndexMode2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + IndexMode2[(IndexMode2['HALFVEC'] = 1)] = 'HALFVEC'; + IndexMode2[(IndexMode2['BINARY'] = 2)] = 'BINARY'; + IndexMode2[(IndexMode2['BINARY_WITH_RERANK'] = 3)] = 'BINARY_WITH_RERANK'; + IndexMode2[(IndexMode2['BRUTE_FORCE'] = 4)] = 'BRUTE_FORCE'; + IndexMode2[(IndexMode2['RANDOM_SEARCH'] = 5)] = 'RANDOM_SEARCH'; +})(IndexMode || (IndexMode = {})); +proto3.util.setEnumType(IndexMode, 'exa.index_pb.IndexMode', [ + { no: 0, name: 'INDEX_MODE_UNSPECIFIED' }, + { no: 1, name: 'INDEX_MODE_HALFVEC' }, + { no: 2, name: 'INDEX_MODE_BINARY' }, + { no: 3, name: 'INDEX_MODE_BINARY_WITH_RERANK' }, + { no: 4, name: 'INDEX_MODE_BRUTE_FORCE' }, + { no: 5, name: 'INDEX_MODE_RANDOM_SEARCH' }, +]); +var IndexingStatus; +(function (IndexingStatus2) { + IndexingStatus2[(IndexingStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + IndexingStatus2[(IndexingStatus2['ERROR'] = 1)] = 'ERROR'; + IndexingStatus2[(IndexingStatus2['QUEUED'] = 2)] = 'QUEUED'; + IndexingStatus2[(IndexingStatus2['CLONING_REPO'] = 3)] = 'CLONING_REPO'; + IndexingStatus2[(IndexingStatus2['SCANNING_REPO'] = 4)] = 'SCANNING_REPO'; + IndexingStatus2[(IndexingStatus2['GENERATING_EMBEDDINGS'] = 5)] = + 'GENERATING_EMBEDDINGS'; + IndexingStatus2[(IndexingStatus2['VECTOR_INDEXING'] = 6)] = 'VECTOR_INDEXING'; + IndexingStatus2[(IndexingStatus2['DONE'] = 7)] = 'DONE'; + IndexingStatus2[(IndexingStatus2['CANCELING'] = 8)] = 'CANCELING'; + IndexingStatus2[(IndexingStatus2['CANCELED'] = 9)] = 'CANCELED'; +})(IndexingStatus || (IndexingStatus = {})); +proto3.util.setEnumType(IndexingStatus, 'exa.index_pb.IndexingStatus', [ + { no: 0, name: 'INDEXING_STATUS_UNSPECIFIED' }, + { no: 1, name: 'INDEXING_STATUS_ERROR' }, + { no: 2, name: 'INDEXING_STATUS_QUEUED' }, + { no: 3, name: 'INDEXING_STATUS_CLONING_REPO' }, + { no: 4, name: 'INDEXING_STATUS_SCANNING_REPO' }, + { no: 5, name: 'INDEXING_STATUS_GENERATING_EMBEDDINGS' }, + { no: 6, name: 'INDEXING_STATUS_VECTOR_INDEXING' }, + { no: 7, name: 'INDEXING_STATUS_DONE' }, + { no: 8, name: 'INDEXING_STATUS_CANCELING' }, + { no: 9, name: 'INDEXING_STATUS_CANCELED' }, +]); +var IndexDbVersion = class _IndexDbVersion extends Message { + /** + * Overrides the default versions specified in constants/index.go. + * A change will cause all repositories to be reindexed on redeployment of the + * index service. Intended for cases where existing indexing data needs to be + * invalidated, ex. upon a change in the embedding model, db model, or cci + * parsing + * + * @generated from field: int32 version = 1; + */ + version = 0; + /** + * @generated from field: int32 enterprise_version = 2; + */ + enterpriseVersion = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexDbVersion'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'version', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'enterprise_version', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _IndexDbVersion().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexDbVersion().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexDbVersion().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexDbVersion, a, b); + } +}; +var IndexBuildConfig = class _IndexBuildConfig extends Message { + /** + * @generated from field: exa.index_pb.IndexDbVersion db_version = 2; + */ + dbVersion; + /** + * @generated from field: int32 cci_timeout_secs = 3; + */ + cciTimeoutSecs = 0; + /** + * @generated from field: exa.index_pb.IndexMode index_mode = 4; + */ + indexMode = IndexMode.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexBuildConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 2, name: 'db_version', kind: 'message', T: IndexDbVersion }, + { + no: 3, + name: 'cci_timeout_secs', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'index_mode', + kind: 'enum', + T: proto3.getEnumType(IndexMode), + }, + ]); + static fromBinary(bytes, options) { + return new _IndexBuildConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexBuildConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexBuildConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexBuildConfig, a, b); + } +}; +var RepositoryConfig = class _RepositoryConfig extends Message { + /** + * @generated from field: string git_url = 1; + */ + gitUrl = ''; + /** + * @generated from field: exa.codeium_common_pb.ScmProvider scm_provider = 2; + */ + scmProvider = ScmProvider.UNSPECIFIED; + /** + * @generated from field: exa.index_pb.RepositoryConfig.AutoIndexConfig auto_index_config = 3; + */ + autoIndexConfig; + /** + * @generated from field: bool store_snippets = 4; + */ + storeSnippets = false; + /** + * @generated from field: repeated string whitelisted_groups = 5; + */ + whitelistedGroups = []; + /** + * @generated from field: bool use_github_app = 6; + */ + useGithubApp = false; + /** + * @generated from field: string auth_uid = 7; + */ + authUid = ''; + /** + * @generated from field: string email = 9; + */ + email = ''; + /** + * @generated from field: string service_key_id = 8; + */ + serviceKeyId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.RepositoryConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'git_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'scm_provider', + kind: 'enum', + T: proto3.getEnumType(ScmProvider), + }, + { + no: 3, + name: 'auto_index_config', + kind: 'message', + T: RepositoryConfig_AutoIndexConfig, + }, + { + no: 4, + name: 'store_snippets', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 5, name: 'whitelisted_groups', kind: 'scalar', T: 9, repeated: true }, + { + no: 6, + name: 'use_github_app', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'auth_uid', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'email', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'service_key_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _RepositoryConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RepositoryConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RepositoryConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RepositoryConfig, a, b); + } +}; +var RepositoryConfig_AutoIndexConfig = class _RepositoryConfig_AutoIndexConfig extends Message { + /** + * @generated from field: string branch_name = 1; + */ + branchName = ''; + /** + * Interval with which to automatically index the latest + * commit of the provided branch. + * + * @generated from field: google.protobuf.Duration interval = 2; + */ + interval; + /** + * Automatically prune oldest auto-indexes when number of + * them exceeds this amount. Only considers indexes that + * are in the DONE state. + * + * @generated from field: int32 max_num_auto_indexes = 3; + */ + maxNumAutoIndexes = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.RepositoryConfig.AutoIndexConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'branch_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'interval', kind: 'message', T: Duration }, + { + no: 3, + name: 'max_num_auto_indexes', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _RepositoryConfig_AutoIndexConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RepositoryConfig_AutoIndexConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RepositoryConfig_AutoIndexConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_RepositoryConfig_AutoIndexConfig, a, b); + } +}; +var IndexConfig = class _IndexConfig extends Message { + /** + * @generated from field: google.protobuf.Timestamp prune_time = 1; + */ + pruneTime; + /** + * @generated from field: google.protobuf.Duration prune_interval = 2; + */ + pruneInterval; + /** + * @generated from field: bool enable_prune = 3; + */ + enablePrune = false; + /** + * @generated from field: bool enable_smallest_repo_first = 4; + */ + enableSmallestRepoFirst = false; + /** + * @generated from field: bool enable_round_robin = 5; + */ + enableRoundRobin = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'prune_time', kind: 'message', T: Timestamp }, + { no: 2, name: 'prune_interval', kind: 'message', T: Duration }, + { + no: 3, + name: 'enable_prune', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'enable_smallest_repo_first', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'enable_round_robin', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _IndexConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexConfig, a, b); + } +}; +var VectorIndexStats = class _VectorIndexStats extends Message { + /** + * @generated from field: int64 num_embeddings = 1; + */ + numEmbeddings = protoInt64.zero; + /** + * @generated from field: int64 index_bytes_count = 2; + */ + indexBytesCount = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.VectorIndexStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'num_embeddings', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 2, + name: 'index_bytes_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _VectorIndexStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _VectorIndexStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _VectorIndexStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_VectorIndexStats, a, b); + } +}; +var ProgressBar = class _ProgressBar extends Message { + /** + * Negative progress is used to denote that the progress is not known. This is + * useful if we want to report some information through the text only. + * + * @generated from field: float progress = 1; + */ + progress = 0; + /** + * @generated from field: string text = 2; + */ + text = ''; + /** + * @generated from field: google.protobuf.Duration remaining_time = 3; + */ + remainingTime; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.ProgressBar'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'progress', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 2, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'remaining_time', kind: 'message', T: Duration }, + ]); + static fromBinary(bytes, options) { + return new _ProgressBar().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ProgressBar().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ProgressBar().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ProgressBar, a, b); + } +}; +var Index = class _Index extends Message { + /** + * @generated from field: string id = 1; + */ + id = ''; + /** + * @generated from field: string repo_name = 2; + */ + repoName = ''; + /** + * @generated from field: string workspace = 3; + */ + workspace = ''; + /** + * @generated from field: exa.codeium_common_pb.GitRepoInfo repo_info = 4; + */ + repoInfo; + /** + * @generated from field: google.protobuf.Timestamp created_at = 5; + */ + createdAt; + /** + * @generated from field: google.protobuf.Timestamp updated_at = 6; + */ + updatedAt; + /** + * @generated from field: google.protobuf.Timestamp scheduled_at = 13; + */ + scheduledAt; + /** + * @generated from field: exa.index_pb.IndexingStatus status = 7; + */ + status = IndexingStatus.UNSPECIFIED; + /** + * @generated from field: string status_detail = 8; + */ + statusDetail = ''; + /** + * Whether or not the index was auto-indexed. + * + * @generated from field: bool auto_indexed = 9; + */ + autoIndexed = false; + /** + * Whether the index has snippets stored in the database. + * + * @generated from field: bool has_snippets = 12; + */ + hasSnippets = false; + /** + * @generated from field: string auth_uid = 15; + */ + authUid = ''; + /** + * @generated from field: string email = 16; + */ + email = ''; + /** + * @generated from field: exa.index_pb.Index.RepoStats repo_stats = 14; + */ + repoStats; + /** + * The below fields are not directly stored in the indices postgres table. + * The DB client will not return these directly when "getting" index. + * + * @generated from field: map indexing_progress = 10; + */ + indexingProgress = {}; + /** + * Only valid to consume if index is DONE. + * + * @generated from field: exa.index_pb.VectorIndexStats index_stats = 11; + */ + indexStats; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.Index'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'workspace', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'repo_info', kind: 'message', T: GitRepoInfo }, + { no: 5, name: 'created_at', kind: 'message', T: Timestamp }, + { no: 6, name: 'updated_at', kind: 'message', T: Timestamp }, + { no: 13, name: 'scheduled_at', kind: 'message', T: Timestamp }, + { + no: 7, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(IndexingStatus), + }, + { + no: 8, + name: 'status_detail', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'auto_indexed', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 12, + name: 'has_snippets', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 15, + name: 'auth_uid', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 16, + name: 'email', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 14, name: 'repo_stats', kind: 'message', T: Index_RepoStats }, + { + no: 10, + name: 'indexing_progress', + kind: 'map', + K: 9, + V: { kind: 'message', T: ProgressBar }, + }, + { no: 11, name: 'index_stats', kind: 'message', T: VectorIndexStats }, + ]); + static fromBinary(bytes, options) { + return new _Index().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Index().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Index().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Index, a, b); + } +}; +var Index_RepoStats = class _Index_RepoStats extends Message { + /** + * @generated from field: int64 size = 1; + */ + size = protoInt64.zero; + /** + * @generated from field: int64 file_count = 2; + */ + fileCount = protoInt64.zero; + /** + * @generated from field: int64 size_no_ignore = 3; + */ + sizeNoIgnore = protoInt64.zero; + /** + * @generated from field: int64 file_count_no_ignore = 4; + */ + fileCountNoIgnore = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.Index.RepoStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'size', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 2, + name: 'file_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 3, + name: 'size_no_ignore', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 4, + name: 'file_count_no_ignore', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _Index_RepoStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Index_RepoStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Index_RepoStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Index_RepoStats, a, b); + } +}; +var Repository2 = class _Repository extends Message { + /** + * Repositories are unique with respec to repo_name. + * + * @generated from field: string repo_name = 1; + */ + repoName = ''; + /** + * Git URL will be redacted if message is used for response. + * + * @generated from field: exa.index_pb.RepositoryConfig config = 2; + */ + config; + /** + * @generated from field: google.protobuf.Timestamp created_at = 4; + */ + createdAt; + /** + * @generated from field: google.protobuf.Timestamp updated_at = 5; + */ + updatedAt; + /** + * @generated from field: google.protobuf.Timestamp last_used_at = 6; + */ + lastUsedAt; + /** + * The below fields are not directly stored in the indices postgres table. + * The DB client will not return these directly when "getting" repository. + * + * @generated from field: exa.index_pb.Index latest_index = 3; + */ + latestIndex; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.Repository'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'config', kind: 'message', T: RepositoryConfig }, + { no: 4, name: 'created_at', kind: 'message', T: Timestamp }, + { no: 5, name: 'updated_at', kind: 'message', T: Timestamp }, + { no: 6, name: 'last_used_at', kind: 'message', T: Timestamp }, + { no: 3, name: 'latest_index', kind: 'message', T: Index }, + ]); + static fromBinary(bytes, options) { + return new _Repository().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Repository().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Repository().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Repository, a, b); + } +}; +var RequestIndexVersion = class _RequestIndexVersion extends Message { + /** + * @generated from oneof exa.index_pb.RequestIndexVersion.version + */ + version = { case: void 0 }; + /** + * Optional alias for the version of the repo to index. + * + * @generated from field: string version_alias = 3; + */ + versionAlias = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.RequestIndexVersion'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'commit', kind: 'scalar', T: 9, oneof: 'version' }, + { no: 2, name: 'branch', kind: 'scalar', T: 9, oneof: 'version' }, + { + no: 3, + name: 'version_alias', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _RequestIndexVersion().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RequestIndexVersion().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RequestIndexVersion().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RequestIndexVersion, a, b); + } +}; +var ManagementMetadata = class _ManagementMetadata extends Message { + /** + * This is temporary one time auth_token generated by user. + * + * @generated from field: string auth_token = 1; + */ + authToken = ''; + /** + * This is not set by clients but is rather used internally for tracking + * users' requests. + * + * @generated from field: string auth_uid = 2; + */ + authUid = ''; + /** + * This is long lasting service_key generated by user. + * + * @generated from field: string service_key = 3; + */ + serviceKey = ''; + /** + * Only used by Codeium internal team to forcefully target the public indexing + * service rather than the team-specific indexing service instance. + * + * @generated from field: bool force_target_public_index = 4; + */ + forceTargetPublicIndex = false; + /** + * Only used by Codeium internal team to forcefully target a specific indexing + * service rather than the team-specific indexing service instance, for use + * with eval pipelines. + * + * @generated from field: string force_team_id = 5; + */ + forceTeamId = ''; + /** + * @generated from field: string service_key_id = 6; + */ + serviceKeyId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.ManagementMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'auth_token', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'auth_uid', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'service_key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'force_target_public_index', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'force_team_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'service_key_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ManagementMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ManagementMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ManagementMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ManagementMetadata, a, b); + } +}; +var AddRepositoryRequest = class _AddRepositoryRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: exa.index_pb.RepositoryConfig config = 2; + */ + config; + /** + * Request for the first index of this repository. + * + * Only used by Codeium internal team to forcefully target the public indexing + * service rather than the team-specific indexing service instance. + * + * @generated from field: exa.index_pb.RequestIndexVersion initial_index = 3; + */ + initialIndex; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.AddRepositoryRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { no: 2, name: 'config', kind: 'message', T: RepositoryConfig }, + { no: 3, name: 'initial_index', kind: 'message', T: RequestIndexVersion }, + ]); + static fromBinary(bytes, options) { + return new _AddRepositoryRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AddRepositoryRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AddRepositoryRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AddRepositoryRequest, a, b); + } +}; +var AddRepositoryResponse = class _AddRepositoryResponse extends Message { + /** + * @generated from field: string repo_name = 1; + */ + repoName = ''; + /** + * @generated from field: string index_id = 2; + */ + indexId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.AddRepositoryResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'index_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _AddRepositoryResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AddRepositoryResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AddRepositoryResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AddRepositoryResponse, a, b); + } +}; +var EnableIndexingRequest = class _EnableIndexingRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: exa.index_pb.IndexBuildConfig config = 2; + */ + config; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.EnableIndexingRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { no: 2, name: 'config', kind: 'message', T: IndexBuildConfig }, + ]); + static fromBinary(bytes, options) { + return new _EnableIndexingRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _EnableIndexingRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _EnableIndexingRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_EnableIndexingRequest, a, b); + } +}; +var EnableIndexingResponse = class _EnableIndexingResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.EnableIndexingResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _EnableIndexingResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _EnableIndexingResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _EnableIndexingResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_EnableIndexingResponse, a, b); + } +}; +var DisableIndexingRequest = class _DisableIndexingRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.DisableIndexingRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + ]); + static fromBinary(bytes, options) { + return new _DisableIndexingRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DisableIndexingRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DisableIndexingRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DisableIndexingRequest, a, b); + } +}; +var DisableIndexingResponse = class _DisableIndexingResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.DisableIndexingResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _DisableIndexingResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DisableIndexingResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DisableIndexingResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DisableIndexingResponse, a, b); + } +}; +var EditRepositoryRequest = class _EditRepositoryRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: string repo_name = 2; + */ + repoName = ''; + /** + * Git url from config must match the repo_name. + * + * @generated from field: exa.index_pb.RepositoryConfig config = 3; + */ + config; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.EditRepositoryRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'config', kind: 'message', T: RepositoryConfig }, + ]); + static fromBinary(bytes, options) { + return new _EditRepositoryRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _EditRepositoryRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _EditRepositoryRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_EditRepositoryRequest, a, b); + } +}; +var EditRepositoryResponse = class _EditRepositoryResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.EditRepositoryResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _EditRepositoryResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _EditRepositoryResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _EditRepositoryResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_EditRepositoryResponse, a, b); + } +}; +var DeleteRepositoryRequest = class _DeleteRepositoryRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: string repo_name = 2; + */ + repoName = ''; + /** + * @generated from field: repeated string repo_names = 3; + */ + repoNames = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.DeleteRepositoryRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'repo_names', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _DeleteRepositoryRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DeleteRepositoryRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DeleteRepositoryRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DeleteRepositoryRequest, a, b); + } +}; +var DeleteRepositoryResponse = class _DeleteRepositoryResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.DeleteRepositoryResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _DeleteRepositoryResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DeleteRepositoryResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DeleteRepositoryResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DeleteRepositoryResponse, a, b); + } +}; +var GetRepositoriesFilter = class _GetRepositoriesFilter extends Message { + /** + * @generated from field: string repo_name = 1; + */ + repoName = ''; + /** + * @generated from field: string group_id = 2; + */ + groupId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetRepositoriesFilter'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'group_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _GetRepositoriesFilter().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetRepositoriesFilter().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetRepositoriesFilter().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetRepositoriesFilter, a, b); + } +}; +var GetRepositoriesRequest = class _GetRepositoriesRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * Filter for repos with the group_id whitelisted. + * + * @generated from field: exa.index_pb.GetRepositoriesFilter filter = 2; + */ + filter; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetRepositoriesRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { no: 2, name: 'filter', kind: 'message', T: GetRepositoriesFilter }, + ]); + static fromBinary(bytes, options) { + return new _GetRepositoriesRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetRepositoriesRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetRepositoriesRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetRepositoriesRequest, a, b); + } +}; +var GetRepositoriesResponse = class _GetRepositoriesResponse extends Message { + /** + * @generated from field: repeated exa.index_pb.Repository repositories = 1; + */ + repositories = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetRepositoriesResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'repositories', + kind: 'message', + T: Repository2, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetRepositoriesResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetRepositoriesResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetRepositoriesResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetRepositoriesResponse, a, b); + } +}; +var GetIndexesRequest = class _GetIndexesRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: string repo_name = 2; + */ + repoName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetIndexesRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _GetIndexesRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetIndexesRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetIndexesRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetIndexesRequest, a, b); + } +}; +var GetIndexesResponse = class _GetIndexesResponse extends Message { + /** + * @generated from field: repeated exa.index_pb.Index indexes = 1; + */ + indexes = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetIndexesResponse'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'indexes', kind: 'message', T: Index, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _GetIndexesResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetIndexesResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetIndexesResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetIndexesResponse, a, b); + } +}; +var GetIndexRequest = class _GetIndexRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: string index_id = 2; + */ + indexId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetIndexRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'index_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _GetIndexRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetIndexRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetIndexRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetIndexRequest, a, b); + } +}; +var GetIndexResponse = class _GetIndexResponse extends Message { + /** + * @generated from field: exa.index_pb.Index index = 1; + */ + index; + /** + * @generated from field: exa.index_pb.Repository repository = 2; + */ + repository; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetIndexResponse'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'index', kind: 'message', T: Index }, + { no: 2, name: 'repository', kind: 'message', T: Repository2 }, + ]); + static fromBinary(bytes, options) { + return new _GetIndexResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetIndexResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetIndexResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetIndexResponse, a, b); + } +}; +var RemoteIndexStats = class _RemoteIndexStats extends Message { + /** + * @generated from field: string index_id = 1; + */ + indexId = ''; + /** + * @generated from field: int64 cci_count = 2; + */ + cciCount = protoInt64.zero; + /** + * @generated from field: int64 snippet_count = 3; + */ + snippetCount = protoInt64.zero; + /** + * @generated from field: int64 embedding_count = 4; + */ + embeddingCount = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.RemoteIndexStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'index_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'cci_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 3, + name: 'snippet_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 4, + name: 'embedding_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _RemoteIndexStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RemoteIndexStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RemoteIndexStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RemoteIndexStats, a, b); + } +}; +var GetRemoteIndexStatsRequest = class _GetRemoteIndexStatsRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: repeated string index_ids = 2; + */ + indexIds = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetRemoteIndexStatsRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { no: 2, name: 'index_ids', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _GetRemoteIndexStatsRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetRemoteIndexStatsRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetRemoteIndexStatsRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetRemoteIndexStatsRequest, a, b); + } +}; +var GetRemoteIndexStatsResponse = class _GetRemoteIndexStatsResponse extends Message { + /** + * @generated from field: repeated exa.index_pb.RemoteIndexStats index_stats = 1; + */ + indexStats = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetRemoteIndexStatsResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'index_stats', + kind: 'message', + T: RemoteIndexStats, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetRemoteIndexStatsResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetRemoteIndexStatsResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetRemoteIndexStatsResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetRemoteIndexStatsResponse, a, b); + } +}; +var AddIndexRequest = class _AddIndexRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: string repo_name = 2; + */ + repoName = ''; + /** + * @generated from field: exa.index_pb.RequestIndexVersion version = 3; + */ + version; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.AddIndexRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'version', kind: 'message', T: RequestIndexVersion }, + ]); + static fromBinary(bytes, options) { + return new _AddIndexRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AddIndexRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AddIndexRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AddIndexRequest, a, b); + } +}; +var AddIndexResponse = class _AddIndexResponse extends Message { + /** + * @generated from field: string index_id = 1; + */ + indexId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.AddIndexResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'index_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _AddIndexResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AddIndexResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AddIndexResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AddIndexResponse, a, b); + } +}; +var CancelIndexingRequest = class _CancelIndexingRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: string index_id = 2; + */ + indexId = ''; + /** + * @generated from field: repeated string index_ids = 3; + */ + indexIds = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.CancelIndexingRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'index_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'index_ids', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _CancelIndexingRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CancelIndexingRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CancelIndexingRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CancelIndexingRequest, a, b); + } +}; +var CancelIndexingResponse = class _CancelIndexingResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.CancelIndexingResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CancelIndexingResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CancelIndexingResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CancelIndexingResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CancelIndexingResponse, a, b); + } +}; +var RetryIndexingRequest = class _RetryIndexingRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: string index_id = 2; + */ + indexId = ''; + /** + * @generated from field: repeated string index_ids = 3; + */ + indexIds = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.RetryIndexingRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'index_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'index_ids', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _RetryIndexingRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RetryIndexingRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RetryIndexingRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RetryIndexingRequest, a, b); + } +}; +var RetryIndexingResponse = class _RetryIndexingResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.RetryIndexingResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _RetryIndexingResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RetryIndexingResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RetryIndexingResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RetryIndexingResponse, a, b); + } +}; +var DeleteIndexRequest = class _DeleteIndexRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: string index_id = 2; + */ + indexId = ''; + /** + * @generated from field: repeated string index_ids = 3; + */ + indexIds = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.DeleteIndexRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'index_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'index_ids', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _DeleteIndexRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DeleteIndexRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DeleteIndexRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DeleteIndexRequest, a, b); + } +}; +var DeleteIndexResponse = class _DeleteIndexResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.DeleteIndexResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _DeleteIndexResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DeleteIndexResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DeleteIndexResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DeleteIndexResponse, a, b); + } +}; +var PruneDatabaseRequest = class _PruneDatabaseRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.PruneDatabaseRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + ]); + static fromBinary(bytes, options) { + return new _PruneDatabaseRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PruneDatabaseRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PruneDatabaseRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PruneDatabaseRequest, a, b); + } +}; +var PruneDatabaseResponse = class _PruneDatabaseResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.PruneDatabaseResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _PruneDatabaseResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PruneDatabaseResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PruneDatabaseResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PruneDatabaseResponse, a, b); + } +}; +var GetDatabaseStatsRequest = class _GetDatabaseStatsRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetDatabaseStatsRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + ]); + static fromBinary(bytes, options) { + return new _GetDatabaseStatsRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetDatabaseStatsRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetDatabaseStatsRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetDatabaseStatsRequest, a, b); + } +}; +var GetDatabaseStatsResponse = class _GetDatabaseStatsResponse extends Message { + /** + * @generated from field: int64 database_total_bytes_count = 1; + */ + databaseTotalBytesCount = protoInt64.zero; + /** + * @generated from field: int64 table_total_bytes_count = 2; + */ + tableTotalBytesCount = protoInt64.zero; + /** + * @generated from field: int64 index_total_bytes_count = 3; + */ + indexTotalBytesCount = protoInt64.zero; + /** + * @generated from field: int64 estimate_prunable_bytes = 4; + */ + estimatePrunableBytes = protoInt64.zero; + /** + * Database is in the process of pruning. + * + * @generated from field: bool is_pruning = 5; + */ + isPruning = false; + /** + * @generated from field: string last_prune_error = 6; + */ + lastPruneError = ''; + /** + * Total bytes used by all tables in the database, not just the ones in + * GetTableNames + * + * @generated from field: int64 all_tables_bytes_count = 7; + */ + allTablesBytesCount = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetDatabaseStatsResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'database_total_bytes_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 2, + name: 'table_total_bytes_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 3, + name: 'index_total_bytes_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 4, + name: 'estimate_prunable_bytes', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 5, + name: 'is_pruning', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'last_prune_error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'all_tables_bytes_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _GetDatabaseStatsResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetDatabaseStatsResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetDatabaseStatsResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetDatabaseStatsResponse, a, b); + } +}; +var SetIndexConfigRequest = class _SetIndexConfigRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: exa.index_pb.IndexConfig index_config = 2; + */ + indexConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.SetIndexConfigRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { no: 2, name: 'index_config', kind: 'message', T: IndexConfig }, + ]); + static fromBinary(bytes, options) { + return new _SetIndexConfigRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SetIndexConfigRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SetIndexConfigRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SetIndexConfigRequest, a, b); + } +}; +var SetIndexConfigResponse = class _SetIndexConfigResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.SetIndexConfigResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _SetIndexConfigResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SetIndexConfigResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SetIndexConfigResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SetIndexConfigResponse, a, b); + } +}; +var GetIndexConfigRequest = class _GetIndexConfigRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetIndexConfigRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + ]); + static fromBinary(bytes, options) { + return new _GetIndexConfigRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetIndexConfigRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetIndexConfigRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetIndexConfigRequest, a, b); + } +}; +var GetIndexConfigResponse = class _GetIndexConfigResponse extends Message { + /** + * @generated from field: exa.index_pb.IndexConfig index_config = 1; + */ + indexConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetIndexConfigResponse'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'index_config', kind: 'message', T: IndexConfig }, + ]); + static fromBinary(bytes, options) { + return new _GetIndexConfigResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetIndexConfigResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetIndexConfigResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GetIndexConfigResponse, a, b); + } +}; +var GetNumberConnectionsRequest = class _GetNumberConnectionsRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetNumberConnectionsRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + ]); + static fromBinary(bytes, options) { + return new _GetNumberConnectionsRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetNumberConnectionsRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetNumberConnectionsRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetNumberConnectionsRequest, a, b); + } +}; +var GetNumberConnectionsResponse = class _GetNumberConnectionsResponse extends Message { + /** + * @generated from field: map connections_map = 1; + */ + connectionsMap = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetNumberConnectionsResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'connections_map', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _GetNumberConnectionsResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetNumberConnectionsResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetNumberConnectionsResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetNumberConnectionsResponse, a, b); + } +}; +var GetConnectionsDebugInfoRequest = class _GetConnectionsDebugInfoRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetConnectionsDebugInfoRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + ]); + static fromBinary(bytes, options) { + return new _GetConnectionsDebugInfoRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetConnectionsDebugInfoRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetConnectionsDebugInfoRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetConnectionsDebugInfoRequest, a, b); + } +}; +var GetConnectionsDebugInfoResponse = class _GetConnectionsDebugInfoResponse extends Message { + /** + * @generated from field: string debug_info = 1; + */ + debugInfo = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetConnectionsDebugInfoResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'debug_info', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _GetConnectionsDebugInfoResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetConnectionsDebugInfoResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetConnectionsDebugInfoResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetConnectionsDebugInfoResponse, a, b); + } +}; +var GetIndexedRepositoriesRequest = class _GetIndexedRepositoriesRequest extends Message { + /** + * @generated from field: exa.codeium_common_pb.Metadata metadata = 1; + */ + metadata; + /** + * @generated from field: bool include_incomplete = 2; + */ + includeIncomplete = false; + /** + * @generated from field: repeated string group_ids_filter = 3; + */ + groupIdsFilter = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetIndexedRepositoriesRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: Metadata }, + { + no: 2, + name: 'include_incomplete', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 3, name: 'group_ids_filter', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _GetIndexedRepositoriesRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetIndexedRepositoriesRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetIndexedRepositoriesRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetIndexedRepositoriesRequest, a, b); + } +}; +var GetIndexedRepositoriesResponse = class _GetIndexedRepositoriesResponse extends Message { + /** + * TODO(matt): This field is only kept for backward compatibility, remove in + * the future. + * + * @generated from field: repeated exa.codeium_common_pb.GitRepoInfo repositories = 1; + */ + repositories = []; + /** + * Will not contain progress or index stats. + * + * @generated from field: repeated exa.index_pb.Index indexes = 2; + */ + indexes = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetIndexedRepositoriesResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'repositories', + kind: 'message', + T: GitRepoInfo, + repeated: true, + }, + { no: 2, name: 'indexes', kind: 'message', T: Index, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _GetIndexedRepositoriesResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetIndexedRepositoriesResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetIndexedRepositoriesResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetIndexedRepositoriesResponse, a, b); + } +}; +var RepositoryFilter = class _RepositoryFilter extends Message { + /** + * Owner and name are required. If commit is ommitted, will pick any version. + * + * @generated from field: exa.codeium_common_pb.GitRepoInfo repository = 1; + */ + repository; + /** + * NOTE: This is unimplemented. + * + * @generated from field: repeated string excluded_files = 2; + */ + excludedFiles = []; + /** + * Relative paths to prioritize within the repository. If any filter paths are + * provided, the search limit will be 10x-ed and the results will be + * post-filtered. This is because we cannot filter at query time and use the + * vector index at the same time. Remaining space in the max results will be + * filled up with the rest of the results. A filter path is a match if the + * relative path of the actual file contains the filter path as a prefix. + * + * @generated from field: repeated string filter_paths = 3; + */ + filterPaths = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.RepositoryFilter'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'repository', kind: 'message', T: GitRepoInfo }, + { no: 2, name: 'excluded_files', kind: 'scalar', T: 9, repeated: true }, + { no: 3, name: 'filter_paths', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _RepositoryFilter().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RepositoryFilter().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RepositoryFilter().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RepositoryFilter, a, b); + } +}; +var GetMatchingFilePathsRequest = class _GetMatchingFilePathsRequest extends Message { + /** + * @generated from field: exa.codeium_common_pb.Metadata metadata = 1; + */ + metadata; + /** + * @generated from field: exa.codeium_common_pb.GitRepoInfo repository = 2; + */ + repository; + /** + * @generated from field: string query = 3; + */ + query = ''; + /** + * @generated from field: uint32 max_items = 4; + */ + maxItems = 0; + /** + * @generated from field: repeated string group_ids_filter = 5; + */ + groupIdsFilter = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetMatchingFilePathsRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: Metadata }, + { no: 2, name: 'repository', kind: 'message', T: GitRepoInfo }, + { + no: 3, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'max_items', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 5, name: 'group_ids_filter', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _GetMatchingFilePathsRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetMatchingFilePathsRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetMatchingFilePathsRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetMatchingFilePathsRequest, a, b); + } +}; +var GetMatchingFilePathsResponse = class _GetMatchingFilePathsResponse extends Message { + /** + * @generated from field: repeated string relative_file_paths = 1; + */ + relativeFilePaths = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetMatchingFilePathsResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'relative_file_paths', + kind: 'scalar', + T: 9, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetMatchingFilePathsResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetMatchingFilePathsResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetMatchingFilePathsResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetMatchingFilePathsResponse, a, b); + } +}; +var GetNearestCCIsFromEmbeddingRequest = class _GetNearestCCIsFromEmbeddingRequest extends Message { + /** + * @generated from field: exa.codeium_common_pb.Metadata metadata = 1; + */ + metadata; + /** + * @generated from field: exa.codeium_common_pb.Embedding embedding = 2; + */ + embedding; + /** + * @generated from field: repeated exa.index_pb.RepositoryFilter repository_filters = 3; + */ + repositoryFilters = []; + /** + * @generated from field: int64 max_results = 4; + */ + maxResults = protoInt64.zero; + /** + * list of group ids the user is in, populated by api server + * + * @generated from field: repeated string group_ids_filter = 5; + */ + groupIdsFilter = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetNearestCCIsFromEmbeddingRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: Metadata }, + { no: 2, name: 'embedding', kind: 'message', T: Embedding }, + { + no: 3, + name: 'repository_filters', + kind: 'message', + T: RepositoryFilter, + repeated: true, + }, + { + no: 4, + name: 'max_results', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { no: 5, name: 'group_ids_filter', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _GetNearestCCIsFromEmbeddingRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetNearestCCIsFromEmbeddingRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetNearestCCIsFromEmbeddingRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetNearestCCIsFromEmbeddingRequest, a, b); + } +}; +var ScoredContextItem = class _ScoredContextItem extends Message { + /** + * @generated from field: exa.codeium_common_pb.CodeContextItem code_context_item = 1; + */ + codeContextItem; + /** + * @generated from field: float score = 2; + */ + score = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.ScoredContextItem'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'code_context_item', kind: 'message', T: CodeContextItem }, + { + no: 2, + name: 'score', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + ]); + static fromBinary(bytes, options) { + return new _ScoredContextItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ScoredContextItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ScoredContextItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ScoredContextItem, a, b); + } +}; +var GetNearestCCIsFromEmbeddingResponse = class _GetNearestCCIsFromEmbeddingResponse extends Message { + /** + * @generated from field: repeated exa.index_pb.ScoredContextItem scored_context_items = 1; + */ + scoredContextItems = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetNearestCCIsFromEmbeddingResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'scored_context_items', + kind: 'message', + T: ScoredContextItem, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetNearestCCIsFromEmbeddingResponse().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _GetNearestCCIsFromEmbeddingResponse().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetNearestCCIsFromEmbeddingResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetNearestCCIsFromEmbeddingResponse, a, b); + } +}; +var GetEmbeddingsForCodeContextItemsRequest = class _GetEmbeddingsForCodeContextItemsRequest extends Message { + /** + * @generated from field: exa.codeium_common_pb.Metadata metadata = 1; + */ + metadata; + /** + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem code_context_items = 2; + */ + codeContextItems = []; + /** + * @generated from field: exa.codeium_common_pb.ContextSnippetType snippet_type = 3; + */ + snippetType = ContextSnippetType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetEmbeddingsForCodeContextItemsRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: Metadata }, + { + no: 2, + name: 'code_context_items', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + { + no: 3, + name: 'snippet_type', + kind: 'enum', + T: proto3.getEnumType(ContextSnippetType), + }, + ]); + static fromBinary(bytes, options) { + return new _GetEmbeddingsForCodeContextItemsRequest().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _GetEmbeddingsForCodeContextItemsRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetEmbeddingsForCodeContextItemsRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetEmbeddingsForCodeContextItemsRequest, a, b); + } +}; +var GetEmbeddingsForCodeContextItemsResponse = class _GetEmbeddingsForCodeContextItemsResponse extends Message { + /** + * Index corresponds to the request. + * + * @generated from field: repeated exa.codeium_common_pb.Embedding embeddings = 1; + */ + embeddings = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.GetEmbeddingsForCodeContextItemsResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'embeddings', + kind: 'message', + T: Embedding, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetEmbeddingsForCodeContextItemsResponse().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _GetEmbeddingsForCodeContextItemsResponse().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetEmbeddingsForCodeContextItemsResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetEmbeddingsForCodeContextItemsResponse, a, b); + } +}; +var IndexStats = class _IndexStats extends Message { + /** + * @generated from field: string repository_name = 1; + */ + repositoryName = ''; + /** + * @generated from field: int64 file_count = 2; + */ + fileCount = protoInt64.zero; + /** + * @generated from field: int64 code_context_item_count = 3; + */ + codeContextItemCount = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexStats'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'repository_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'file_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 3, + name: 'code_context_item_count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _IndexStats().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexStats().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexStats().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexStats, a, b); + } +}; +var IndexerEvent = class _IndexerEvent extends Message { + /** + * @generated from field: uint64 uid = 1; + */ + uid = protoInt64.zero; + /** + * @generated from oneof exa.index_pb.IndexerEvent.event_oneof + */ + eventOneof = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexerEvent'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'uid', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'deletion', + kind: 'message', + T: IndexerEvent_Deletion, + oneof: 'event_oneof', + }, + { + no: 3, + name: 'untrack', + kind: 'message', + T: IndexerEvent_Untrack, + oneof: 'event_oneof', + }, + { + no: 4, + name: 'update', + kind: 'message', + T: IndexerEvent_Update, + oneof: 'event_oneof', + }, + { + no: 5, + name: 'add_workspace', + kind: 'message', + T: IndexerEvent_AddWorkspace, + oneof: 'event_oneof', + }, + { + no: 6, + name: 'remove_workspace', + kind: 'message', + T: IndexerEvent_RemoveWorkspace, + oneof: 'event_oneof', + }, + { + no: 7, + name: 'ignore_workspace', + kind: 'message', + T: IndexerEvent_IgnoreWorkspace, + oneof: 'event_oneof', + }, + { + no: 8, + name: 'add_commit', + kind: 'message', + T: IndexerEvent_AddCommit, + oneof: 'event_oneof', + }, + ]); + static fromBinary(bytes, options) { + return new _IndexerEvent().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexerEvent().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexerEvent().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexerEvent, a, b); + } +}; +var IndexerEvent_Deletion = class _IndexerEvent_Deletion extends Message { + /** + * @generated from field: string absolute_uri = 1; + */ + absoluteUri = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexerEvent.Deletion'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _IndexerEvent_Deletion().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexerEvent_Deletion().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexerEvent_Deletion().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexerEvent_Deletion, a, b); + } +}; +var IndexerEvent_Untrack = class _IndexerEvent_Untrack extends Message { + /** + * @generated from field: string absolute_uri = 1; + */ + absoluteUri = ''; + /** + * This contains the remaining active workspaces referencing this file. + * + * @generated from field: repeated exa.codeium_common_pb.WorkspacePath paths = 2; + */ + paths = []; + /** + * This is the workspace that was removed triggering the Untrack event. + * + * @generated from field: string workspace_uri = 3; + */ + workspaceUri = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexerEvent.Untrack'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'paths', kind: 'message', T: WorkspacePath, repeated: true }, + { + no: 3, + name: 'workspace_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _IndexerEvent_Untrack().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexerEvent_Untrack().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexerEvent_Untrack().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexerEvent_Untrack, a, b); + } +}; +var IndexerEvent_Update = class _IndexerEvent_Update extends Message { + /** + * @generated from field: string absolute_uri = 1; + */ + absoluteUri = ''; + /** + * @generated from field: repeated exa.codeium_common_pb.WorkspacePath paths = 2; + */ + paths = []; + /** + * @generated from field: google.protobuf.Timestamp mod_time = 3; + */ + modTime; + /** + * This is populated when the update is triggered by AddWorkspace. + * + * @generated from field: exa.index_pb.IndexerEvent.Update.AddWorkspaceInfo add_workspace_info = 4; + */ + addWorkspaceInfo; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexerEvent.Update'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'paths', kind: 'message', T: WorkspacePath, repeated: true }, + { no: 3, name: 'mod_time', kind: 'message', T: Timestamp }, + { + no: 4, + name: 'add_workspace_info', + kind: 'message', + T: IndexerEvent_Update_AddWorkspaceInfo, + }, + ]); + static fromBinary(bytes, options) { + return new _IndexerEvent_Update().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexerEvent_Update().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexerEvent_Update().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexerEvent_Update, a, b); + } +}; +var IndexerEvent_Update_AddWorkspaceInfo = class _IndexerEvent_Update_AddWorkspaceInfo extends Message { + /** + * @generated from field: uint64 add_workspace_uid = 1; + */ + addWorkspaceUid = protoInt64.zero; + /** + * This is assigned when the workspace is about to be inserted into the + * queue. + * + * @generated from field: uint64 add_workspace_queue_uid = 2; + */ + addWorkspaceQueueUid = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexerEvent.Update.AddWorkspaceInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'add_workspace_uid', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'add_workspace_queue_uid', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _IndexerEvent_Update_AddWorkspaceInfo().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _IndexerEvent_Update_AddWorkspaceInfo().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _IndexerEvent_Update_AddWorkspaceInfo().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_IndexerEvent_Update_AddWorkspaceInfo, a, b); + } +}; +var IndexerEvent_AddWorkspace = class _IndexerEvent_AddWorkspace extends Message { + /** + * @generated from field: uint64 add_workspace_uid = 1; + */ + addWorkspaceUid = protoInt64.zero; + /** + * This is assigned when the workspace is about to be inserted into the + * queue. + * + * @generated from field: uint64 add_workspace_queue_uid = 2; + */ + addWorkspaceQueueUid = protoInt64.zero; + /** + * @generated from field: string workspace_uri = 3; + */ + workspaceUri = ''; + /** + * This is signed just for type convenience in Go code. + * + * @generated from field: int64 num_files = 4; + */ + numFiles = protoInt64.zero; + /** + * Used for smallest repo first scheduling. + * + * @generated from field: int64 size = 5; + */ + size = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexerEvent.AddWorkspace'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'add_workspace_uid', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 2, + name: 'add_workspace_queue_uid', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 3, + name: 'workspace_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'num_files', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 5, + name: 'size', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _IndexerEvent_AddWorkspace().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexerEvent_AddWorkspace().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexerEvent_AddWorkspace().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexerEvent_AddWorkspace, a, b); + } +}; +var IndexerEvent_RemoveWorkspace = class _IndexerEvent_RemoveWorkspace extends Message { + /** + * @generated from field: string workspace_uri = 1; + */ + workspaceUri = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexerEvent.RemoveWorkspace'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'workspace_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _IndexerEvent_RemoveWorkspace().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexerEvent_RemoveWorkspace().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexerEvent_RemoveWorkspace().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_IndexerEvent_RemoveWorkspace, a, b); + } +}; +var IndexerEvent_IgnoreWorkspace = class _IndexerEvent_IgnoreWorkspace extends Message { + /** + * @generated from field: string workspace_uri = 1; + */ + workspaceUri = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexerEvent.IgnoreWorkspace'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'workspace_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _IndexerEvent_IgnoreWorkspace().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexerEvent_IgnoreWorkspace().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexerEvent_IgnoreWorkspace().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_IndexerEvent_IgnoreWorkspace, a, b); + } +}; +var IndexerEvent_AddCommit = class _IndexerEvent_AddCommit extends Message { + /** + * @generated from field: string sha = 1; + */ + sha = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.index_pb.IndexerEvent.AddCommit'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'sha', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _IndexerEvent_AddCommit().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IndexerEvent_AddCommit().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IndexerEvent_AddCommit().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IndexerEvent_AddCommit, a, b); + } +}; + +// exa/proto_ts/dist/exa/opensearch_clients_pb/opensearch_clients_pb.js +var SearchMode; +(function (SearchMode2) { + SearchMode2[(SearchMode2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + SearchMode2[(SearchMode2['HYBRID'] = 1)] = 'HYBRID'; + SearchMode2[(SearchMode2['KEYWORD'] = 2)] = 'KEYWORD'; + SearchMode2[(SearchMode2['APPROXIMATE_KNN'] = 3)] = 'APPROXIMATE_KNN'; + SearchMode2[(SearchMode2['BRUTE_FORCE_KNN'] = 4)] = 'BRUTE_FORCE_KNN'; +})(SearchMode || (SearchMode = {})); +proto3.util.setEnumType(SearchMode, 'exa.opensearch_clients_pb.SearchMode', [ + { no: 0, name: 'SEARCH_MODE_UNSPECIFIED' }, + { no: 1, name: 'SEARCH_MODE_HYBRID' }, + { no: 2, name: 'SEARCH_MODE_KEYWORD' }, + { no: 3, name: 'SEARCH_MODE_APPROXIMATE_KNN' }, + { no: 4, name: 'SEARCH_MODE_BRUTE_FORCE_KNN' }, +]); +var ForwardStatus; +(function (ForwardStatus2) { + ForwardStatus2[(ForwardStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ForwardStatus2[(ForwardStatus2['FAILURE'] = 1)] = 'FAILURE'; + ForwardStatus2[(ForwardStatus2['SAVED'] = 2)] = 'SAVED'; + ForwardStatus2[(ForwardStatus2['SUCCESS'] = 3)] = 'SUCCESS'; +})(ForwardStatus || (ForwardStatus = {})); +proto3.util.setEnumType( + ForwardStatus, + 'exa.opensearch_clients_pb.ForwardStatus', + [ + { no: 0, name: 'FORWARD_STATUS_UNSPECIFIED' }, + { no: 1, name: 'FORWARD_STATUS_FAILURE' }, + { no: 2, name: 'FORWARD_STATUS_SAVED' }, + { no: 3, name: 'FORWARD_STATUS_SUCCESS' }, + ], +); +var ConnectorType; +(function (ConnectorType2) { + ConnectorType2[(ConnectorType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ConnectorType2[(ConnectorType2['GITHUB'] = 1)] = 'GITHUB'; + ConnectorType2[(ConnectorType2['SLACK'] = 2)] = 'SLACK'; + ConnectorType2[(ConnectorType2['GOOGLE_DRIVE'] = 3)] = 'GOOGLE_DRIVE'; + ConnectorType2[(ConnectorType2['JIRA'] = 4)] = 'JIRA'; + ConnectorType2[(ConnectorType2['CODEIUM'] = 5)] = 'CODEIUM'; + ConnectorType2[(ConnectorType2['EMAIL'] = 6)] = 'EMAIL'; + ConnectorType2[(ConnectorType2['GITHUB_OAUTH'] = 7)] = 'GITHUB_OAUTH'; +})(ConnectorType || (ConnectorType = {})); +proto3.util.setEnumType( + ConnectorType, + 'exa.opensearch_clients_pb.ConnectorType', + [ + { no: 0, name: 'CONNECTOR_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CONNECTOR_TYPE_GITHUB' }, + { no: 2, name: 'CONNECTOR_TYPE_SLACK' }, + { no: 3, name: 'CONNECTOR_TYPE_GOOGLE_DRIVE' }, + { no: 4, name: 'CONNECTOR_TYPE_JIRA' }, + { no: 5, name: 'CONNECTOR_TYPE_CODEIUM' }, + { no: 6, name: 'CONNECTOR_TYPE_EMAIL' }, + { no: 7, name: 'CONNECTOR_TYPE_GITHUB_OAUTH' }, + ], +); +var JobStatus; +(function (JobStatus2) { + JobStatus2[(JobStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + JobStatus2[(JobStatus2['QUEUED'] = 1)] = 'QUEUED'; + JobStatus2[(JobStatus2['RUNNING'] = 2)] = 'RUNNING'; + JobStatus2[(JobStatus2['COMPLETED'] = 3)] = 'COMPLETED'; + JobStatus2[(JobStatus2['CANCELLED'] = 4)] = 'CANCELLED'; + JobStatus2[(JobStatus2['CANCELLING'] = 5)] = 'CANCELLING'; + JobStatus2[(JobStatus2['ERRORED'] = 6)] = 'ERRORED'; + JobStatus2[(JobStatus2['RETRYABLE'] = 7)] = 'RETRYABLE'; +})(JobStatus || (JobStatus = {})); +proto3.util.setEnumType(JobStatus, 'exa.opensearch_clients_pb.JobStatus', [ + { no: 0, name: 'JOB_STATUS_UNSPECIFIED' }, + { no: 1, name: 'JOB_STATUS_QUEUED' }, + { no: 2, name: 'JOB_STATUS_RUNNING' }, + { no: 3, name: 'JOB_STATUS_COMPLETED' }, + { no: 4, name: 'JOB_STATUS_CANCELLED' }, + { no: 5, name: 'JOB_STATUS_CANCELLING' }, + { no: 6, name: 'JOB_STATUS_ERRORED' }, + { no: 7, name: 'JOB_STATUS_RETRYABLE' }, +]); +var TimeRange = class _TimeRange extends Message { + /** + * @generated from field: google.protobuf.Timestamp start = 1; + */ + start; + /** + * @generated from field: google.protobuf.Timestamp end = 2; + */ + end; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.TimeRange'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'start', kind: 'message', T: Timestamp }, + { no: 2, name: 'end', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _TimeRange().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TimeRange().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TimeRange().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TimeRange, a, b); + } +}; +var GithubUser = class _GithubUser extends Message { + /** + * @generated from field: string auth_uid = 1; + */ + authUid = ''; + /** + * @generated from field: string username = 2; + */ + username = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.GithubUser'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'auth_uid', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'username', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _GithubUser().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GithubUser().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GithubUser().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GithubUser, a, b); + } +}; +var AddGithubUsersRequest = class _AddGithubUsersRequest extends Message { + /** + * This is not required, because the list can be empty + * + * @generated from field: repeated exa.opensearch_clients_pb.GithubUser users = 1; + */ + users = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.AddGithubUsersRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'users', kind: 'message', T: GithubUser, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _AddGithubUsersRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AddGithubUsersRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AddGithubUsersRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AddGithubUsersRequest, a, b); + } +}; +var AddGithubUsersResponse = class _AddGithubUsersResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.AddGithubUsersResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _AddGithubUsersResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AddGithubUsersResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AddGithubUsersResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AddGithubUsersResponse, a, b); + } +}; +var UserInfo = class _UserInfo extends Message { + /** + * @generated from field: string auth_uid = 1; + */ + authUid = ''; + /** + * @generated from field: string email = 2; + */ + email = ''; + /** + * @generated from field: string name = 3; + */ + name = ''; + /** + * @generated from field: string photo_url = 4; + */ + photoUrl = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.UserInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'auth_uid', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'email', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'photo_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _UserInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserInfo, a, b); + } +}; +var AddUsersRequest = class _AddUsersRequest extends Message { + /** + * @generated from field: repeated exa.opensearch_clients_pb.UserInfo users = 1; + */ + users = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.AddUsersRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'users', kind: 'message', T: UserInfo, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _AddUsersRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AddUsersRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AddUsersRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AddUsersRequest, a, b); + } +}; +var AddUsersResponse = class _AddUsersResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.AddUsersResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _AddUsersResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AddUsersResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AddUsersResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AddUsersResponse, a, b); + } +}; +var KnowledgeBaseSearchRequest = class _KnowledgeBaseSearchRequest extends Message { + /** + * @generated from field: int64 max_results = 2; + */ + maxResults = protoInt64.zero; + /** + * @generated from field: repeated string queries = 3; + */ + queries = []; + /** + * @generated from field: exa.codeium_common_pb.Metadata metadata = 4; + */ + metadata; + /** + * @generated from field: repeated string urls = 12; + */ + urls = []; + /** + * @generated from field: repeated string document_ids = 13; + */ + documentIds = []; + /** + * @generated from field: repeated string aggregate_ids = 5; + */ + aggregateIds = []; + /** + * @generated from field: repeated exa.chat_pb.ChatMessagePrompt chat_message_prompts = 6; + */ + chatMessagePrompts = []; + /** + * @generated from field: exa.opensearch_clients_pb.TimeRange time_range = 7; + */ + timeRange; + /** + * @generated from field: repeated exa.codeium_common_pb.DocumentType document_types = 14; + */ + documentTypes = []; + /** + * Optional. If not specified, will use hybrid search. + * + * @generated from field: exa.opensearch_clients_pb.SearchMode search_mode = 9; + */ + searchMode = SearchMode.UNSPECIFIED; + /** + * @generated from field: bool disable_reranking = 10; + */ + disableReranking = false; + /** + * @generated from field: bool disable_contextual_lookup = 11; + */ + disableContextualLookup = false; + /** + * Optional. If not specified, will search over all indexes. + * + * @generated from field: repeated exa.codeium_common_pb.IndexChoice index_choices = 8; + */ + indexChoices = []; + /** + * Deprecated + * + * @generated from field: string query = 1 [deprecated = true]; + * @deprecated + */ + query = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.KnowledgeBaseSearchRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 2, + name: 'max_results', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { no: 3, name: 'queries', kind: 'scalar', T: 9, repeated: true }, + { no: 4, name: 'metadata', kind: 'message', T: Metadata }, + { no: 12, name: 'urls', kind: 'scalar', T: 9, repeated: true }, + { no: 13, name: 'document_ids', kind: 'scalar', T: 9, repeated: true }, + { no: 5, name: 'aggregate_ids', kind: 'scalar', T: 9, repeated: true }, + { + no: 6, + name: 'chat_message_prompts', + kind: 'message', + T: ChatMessagePrompt, + repeated: true, + }, + { no: 7, name: 'time_range', kind: 'message', T: TimeRange }, + { + no: 14, + name: 'document_types', + kind: 'enum', + T: proto3.getEnumType(DocumentType), + repeated: true, + }, + { + no: 9, + name: 'search_mode', + kind: 'enum', + T: proto3.getEnumType(SearchMode), + }, + { + no: 10, + name: 'disable_reranking', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 11, + name: 'disable_contextual_lookup', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 8, + name: 'index_choices', + kind: 'enum', + T: proto3.getEnumType(IndexChoice), + repeated: true, + }, + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeBaseSearchRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeBaseSearchRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeBaseSearchRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeBaseSearchRequest, a, b); + } +}; +var KnowledgeBaseSearchResponse = class _KnowledgeBaseSearchResponse extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseGroup knowledge_base_groups = 1; + */ + knowledgeBaseGroups = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.KnowledgeBaseSearchResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'knowledge_base_groups', + kind: 'message', + T: KnowledgeBaseGroup, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeBaseSearchResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeBaseSearchResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeBaseSearchResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeBaseSearchResponse, a, b); + } +}; +var GetKnowledgeBaseScopeItemsRequest = class _GetKnowledgeBaseScopeItemsRequest extends Message { + /** + * @generated from field: string query = 1; + */ + query = ''; + /** + * @generated from field: exa.codeium_common_pb.Metadata metadata = 3; + */ + metadata; + /** + * Optional. If not specified, will search over all types. + * + * @generated from field: repeated exa.codeium_common_pb.DocumentType document_types = 5; + */ + documentTypes = []; + /** + * Deprecated + * + * @generated from field: repeated exa.codeium_common_pb.IndexChoice index_choices = 4 [deprecated = true]; + * @deprecated + */ + indexChoices = []; + /** + * Deprecated + * + * @generated from field: repeated string index_names = 2 [deprecated = true]; + * @deprecated + */ + indexNames = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetKnowledgeBaseScopeItemsRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'metadata', kind: 'message', T: Metadata }, + { + no: 5, + name: 'document_types', + kind: 'enum', + T: proto3.getEnumType(DocumentType), + repeated: true, + }, + { + no: 4, + name: 'index_choices', + kind: 'enum', + T: proto3.getEnumType(IndexChoice), + repeated: true, + }, + { no: 2, name: 'index_names', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _GetKnowledgeBaseScopeItemsRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetKnowledgeBaseScopeItemsRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetKnowledgeBaseScopeItemsRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetKnowledgeBaseScopeItemsRequest, a, b); + } +}; +var GetKnowledgeBaseScopeItemsResponse = class _GetKnowledgeBaseScopeItemsResponse extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseScopeItem scope_items = 1; + */ + scopeItems = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetKnowledgeBaseScopeItemsResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'scope_items', + kind: 'message', + T: KnowledgeBaseScopeItem, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetKnowledgeBaseScopeItemsResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetKnowledgeBaseScopeItemsResponse().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetKnowledgeBaseScopeItemsResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetKnowledgeBaseScopeItemsResponse, a, b); + } +}; +var GetKnowledgeBaseItemsFromScopeItemsRequest = class _GetKnowledgeBaseItemsFromScopeItemsRequest extends Message { + /** + * @generated from field: exa.codeium_common_pb.Metadata metadata = 2; + */ + metadata; + /** + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseScopeItem scope_items = 3; + */ + scopeItems = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetKnowledgeBaseItemsFromScopeItemsRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 2, name: 'metadata', kind: 'message', T: Metadata }, + { + no: 3, + name: 'scope_items', + kind: 'message', + T: KnowledgeBaseScopeItem, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetKnowledgeBaseItemsFromScopeItemsRequest().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _GetKnowledgeBaseItemsFromScopeItemsRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetKnowledgeBaseItemsFromScopeItemsRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals( + _GetKnowledgeBaseItemsFromScopeItemsRequest, + a, + b, + ); + } +}; +var GetKnowledgeBaseItemsFromScopeItemsResponse = class _GetKnowledgeBaseItemsFromScopeItemsResponse extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseItemWithMetadata knowledge_base_items_with_metadata = 1; + */ + knowledgeBaseItemsWithMetadata = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetKnowledgeBaseItemsFromScopeItemsResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'knowledge_base_items_with_metadata', + kind: 'message', + T: KnowledgeBaseItemWithMetadata, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetKnowledgeBaseItemsFromScopeItemsResponse().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _GetKnowledgeBaseItemsFromScopeItemsResponse().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetKnowledgeBaseItemsFromScopeItemsResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals( + _GetKnowledgeBaseItemsFromScopeItemsResponse, + a, + b, + ); + } +}; +var IngestSlackDataRequest = class _IngestSlackDataRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: repeated string channel_ids = 2; + */ + channelIds = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestSlackDataRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { no: 2, name: 'channel_ids', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _IngestSlackDataRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestSlackDataRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestSlackDataRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IngestSlackDataRequest, a, b); + } +}; +var IngestSlackDataResponse = class _IngestSlackDataResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestSlackDataResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _IngestSlackDataResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestSlackDataResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestSlackDataResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IngestSlackDataResponse, a, b); + } +}; +var IngestGithubDataRequest = class _IngestGithubDataRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 3; + */ + metadata; + /** + * @generated from field: string organization = 1; + */ + organization = ''; + /** + * @generated from field: string repository = 2; + */ + repository = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestGithubDataRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 3, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 1, + name: 'organization', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'repository', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _IngestGithubDataRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestGithubDataRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestGithubDataRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IngestGithubDataRequest, a, b); + } +}; +var IngestGithubDataResponse = class _IngestGithubDataResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestGithubDataResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _IngestGithubDataResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestGithubDataResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestGithubDataResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IngestGithubDataResponse, a, b); + } +}; +var IngestGoogleDriveDataRequest = class _IngestGoogleDriveDataRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 2; + */ + metadata; + /** + * @generated from field: repeated string folder_ids = 3; + */ + folderIds = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestGoogleDriveDataRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 2, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { no: 3, name: 'folder_ids', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _IngestGoogleDriveDataRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestGoogleDriveDataRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestGoogleDriveDataRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_IngestGoogleDriveDataRequest, a, b); + } +}; +var IngestGoogleDriveDataResponse = class _IngestGoogleDriveDataResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestGoogleDriveDataResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _IngestGoogleDriveDataResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestGoogleDriveDataResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestGoogleDriveDataResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_IngestGoogleDriveDataResponse, a, b); + } +}; +var IngestJiraDataRequest = class _IngestJiraDataRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 4; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestJiraDataRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 4, name: 'metadata', kind: 'message', T: ManagementMetadata }, + ]); + static fromBinary(bytes, options) { + return new _IngestJiraDataRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestJiraDataRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestJiraDataRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IngestJiraDataRequest, a, b); + } +}; +var IngestJiraDataResponse = class _IngestJiraDataResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestJiraDataResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _IngestJiraDataResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestJiraDataResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestJiraDataResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IngestJiraDataResponse, a, b); + } +}; +var IngestJiraPayloadRequest = class _IngestJiraPayloadRequest extends Message { + /** + * @generated from field: string body = 3; + */ + body = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestJiraPayloadRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 3, + name: 'body', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _IngestJiraPayloadRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestJiraPayloadRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestJiraPayloadRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IngestJiraPayloadRequest, a, b); + } +}; +var IngestJiraPayloadResponse = class _IngestJiraPayloadResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestJiraPayloadResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _IngestJiraPayloadResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestJiraPayloadResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestJiraPayloadResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IngestJiraPayloadResponse, a, b); + } +}; +var ForwardResult = class _ForwardResult extends Message { + /** + * TODO(saujasn): Failure should correspond to the request body not being + * saved. + * We do not save the body currently; statuses are always + * 'saved' or 'success'. + * + * @generated from field: exa.opensearch_clients_pb.ForwardStatus status = 1; + */ + status = ForwardStatus.UNSPECIFIED; + /** + * @generated from field: optional string error = 2; + */ + error; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ForwardResult'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(ForwardStatus), + }, + { no: 2, name: 'error', kind: 'scalar', T: 9, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _ForwardResult().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ForwardResult().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ForwardResult().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ForwardResult, a, b); + } +}; +var ForwardSlackPayloadRequest = class _ForwardSlackPayloadRequest extends Message { + /** + * @generated from field: repeated string bodies = 1; + */ + bodies = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ForwardSlackPayloadRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'bodies', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _ForwardSlackPayloadRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ForwardSlackPayloadRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ForwardSlackPayloadRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ForwardSlackPayloadRequest, a, b); + } +}; +var ForwardSlackPayloadResponse = class _ForwardSlackPayloadResponse extends Message { + /** + * We return 1 result per request body. + * + * @generated from field: repeated exa.opensearch_clients_pb.ForwardResult results = 1; + */ + results = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ForwardSlackPayloadResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'results', + kind: 'message', + T: ForwardResult, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ForwardSlackPayloadResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ForwardSlackPayloadResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ForwardSlackPayloadResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ForwardSlackPayloadResponse, a, b); + } +}; +var IngestSlackPayloadRequest = class _IngestSlackPayloadRequest extends Message { + /** + * @generated from field: repeated exa.opensearch_clients_pb.SlackPayload payload = 1; + */ + payload = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestSlackPayloadRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'payload', + kind: 'message', + T: SlackPayload, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _IngestSlackPayloadRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestSlackPayloadRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestSlackPayloadRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IngestSlackPayloadRequest, a, b); + } +}; +var IngestSlackPayloadResponse = class _IngestSlackPayloadResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.IngestSlackPayloadResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _IngestSlackPayloadResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IngestSlackPayloadResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IngestSlackPayloadResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_IngestSlackPayloadResponse, a, b); + } +}; +var CommonDocument = class _CommonDocument extends Message { + /** + * @generated from field: string document_id = 1; + */ + documentId = ''; + /** + * @generated from field: string text = 2; + */ + text = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.CommonDocument'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'document_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CommonDocument().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CommonDocument().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CommonDocument().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CommonDocument, a, b); + } +}; +var CommonDocumentWithScore = class _CommonDocumentWithScore extends Message { + /** + * @generated from field: exa.opensearch_clients_pb.CommonDocument document = 1; + */ + document; + /** + * @generated from field: float score = 2; + */ + score = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.CommonDocumentWithScore'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'document', kind: 'message', T: CommonDocument }, + { + no: 2, + name: 'score', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + ]); + static fromBinary(bytes, options) { + return new _CommonDocumentWithScore().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CommonDocumentWithScore().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CommonDocumentWithScore().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CommonDocumentWithScore, a, b); + } +}; +var SearchResult = class _SearchResult extends Message { + /** + * @generated from field: string text = 1; + */ + text = ''; + /** + * @generated from field: string url = 2; + */ + url = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.SearchResult'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _SearchResult().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SearchResult().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SearchResult().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SearchResult, a, b); + } +}; +var QuerySearchResponse = class _QuerySearchResponse extends Message { + /** + * @generated from field: repeated exa.opensearch_clients_pb.CommonDocumentWithScore document_with_scores = 1; + */ + documentWithScores = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.QuerySearchResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'document_with_scores', + kind: 'message', + T: CommonDocumentWithScore, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _QuerySearchResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _QuerySearchResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _QuerySearchResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_QuerySearchResponse, a, b); + } +}; +var OpenSearchAddRepositoryRequest = class _OpenSearchAddRepositoryRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: exa.index_pb.RepositoryConfig config = 2; + */ + config; + /** + * @generated from field: exa.index_pb.RequestIndexVersion initial_index = 3; + */ + initialIndex; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.OpenSearchAddRepositoryRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { no: 2, name: 'config', kind: 'message', T: RepositoryConfig }, + { no: 3, name: 'initial_index', kind: 'message', T: RequestIndexVersion }, + ]); + static fromBinary(bytes, options) { + return new _OpenSearchAddRepositoryRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _OpenSearchAddRepositoryRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _OpenSearchAddRepositoryRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_OpenSearchAddRepositoryRequest, a, b); + } +}; +var OpenSearchAddRepositoryResponse = class _OpenSearchAddRepositoryResponse extends Message { + /** + * @generated from field: string repo_name = 1; + */ + repoName = ''; + /** + * @generated from field: string index_id = 2; + */ + indexId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.OpenSearchAddRepositoryResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'repo_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'index_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _OpenSearchAddRepositoryResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _OpenSearchAddRepositoryResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _OpenSearchAddRepositoryResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_OpenSearchAddRepositoryResponse, a, b); + } +}; +var OpenSearchGetIndexRequest = class _OpenSearchGetIndexRequest extends Message { + /** + * @generated from field: string index_id = 1; + */ + indexId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.OpenSearchGetIndexRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'index_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _OpenSearchGetIndexRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _OpenSearchGetIndexRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _OpenSearchGetIndexRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_OpenSearchGetIndexRequest, a, b); + } +}; +var OpenSearchGetIndexResponse = class _OpenSearchGetIndexResponse extends Message { + /** + * @generated from field: exa.index_pb.IndexingStatus status = 1; + */ + status = IndexingStatus.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.OpenSearchGetIndexResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(IndexingStatus), + }, + ]); + static fromBinary(bytes, options) { + return new _OpenSearchGetIndexResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _OpenSearchGetIndexResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _OpenSearchGetIndexResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_OpenSearchGetIndexResponse, a, b); + } +}; +var HybridSearchRequest = class _HybridSearchRequest extends Message { + /** + * @generated from field: string query = 1; + */ + query = ''; + /** + * @generated from field: exa.codeium_common_pb.Embedding embedding = 2; + */ + embedding; + /** + * @generated from field: int64 max_results = 3; + */ + maxResults = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.HybridSearchRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'embedding', kind: 'message', T: Embedding }, + { + no: 3, + name: 'max_results', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _HybridSearchRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _HybridSearchRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _HybridSearchRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_HybridSearchRequest, a, b); + } +}; +var HybridSearchResponse = class _HybridSearchResponse extends Message { + /** + * @generated from field: repeated exa.opensearch_clients_pb.CommonDocumentWithScore document_with_scores = 1; + */ + documentWithScores = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.HybridSearchResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'document_with_scores', + kind: 'message', + T: CommonDocumentWithScore, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _HybridSearchResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _HybridSearchResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _HybridSearchResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_HybridSearchResponse, a, b); + } +}; +var GraphSearchRequest = class _GraphSearchRequest extends Message { + /** + * @generated from field: string query = 1; + */ + query = ''; + /** + * @generated from field: exa.codeium_common_pb.Embedding embedding = 2; + */ + embedding; + /** + * @generated from field: int64 max_results = 3; + */ + maxResults = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.GraphSearchRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'embedding', kind: 'message', T: Embedding }, + { + no: 3, + name: 'max_results', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _GraphSearchRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GraphSearchRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GraphSearchRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GraphSearchRequest, a, b); + } +}; +var GraphSearchResponse = class _GraphSearchResponse extends Message { + /** + * @generated from field: repeated exa.opensearch_clients_pb.CommonDocumentWithScore document_with_scores = 1; + */ + documentWithScores = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.GraphSearchResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'document_with_scores', + kind: 'message', + T: CommonDocumentWithScore, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GraphSearchResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GraphSearchResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GraphSearchResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GraphSearchResponse, a, b); + } +}; +var ConnectorConfig = class _ConnectorConfig extends Message { + /** + * @generated from oneof exa.opensearch_clients_pb.ConnectorConfig.config + */ + config = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'slack', + kind: 'message', + T: ConnectorConfigSlack, + oneof: 'config', + }, + { + no: 2, + name: 'github', + kind: 'message', + T: ConnectorConfigGithub, + oneof: 'config', + }, + { + no: 3, + name: 'google_drive', + kind: 'message', + T: ConnectorConfigGoogleDrive, + oneof: 'config', + }, + { + no: 4, + name: 'jira', + kind: 'message', + T: ConnectorConfigJira, + oneof: 'config', + }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorConfig, a, b); + } +}; +var ConnectorConfigSlack = class _ConnectorConfigSlack extends Message { + /** + * @generated from field: repeated string include_channel_ids = 3; + */ + includeChannelIds = []; + /** + * @generated from field: repeated string exclude_channel_ids = 4; + */ + excludeChannelIds = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorConfigSlack'; + static fields = proto3.util.newFieldList(() => [ + { + no: 3, + name: 'include_channel_ids', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 4, + name: 'exclude_channel_ids', + kind: 'scalar', + T: 9, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorConfigSlack().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorConfigSlack().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorConfigSlack().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorConfigSlack, a, b); + } +}; +var ConnectorConfigGithub = class _ConnectorConfigGithub extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorConfigGithub'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _ConnectorConfigGithub().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorConfigGithub().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorConfigGithub().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorConfigGithub, a, b); + } +}; +var ConnectorConfigGoogleDrive = class _ConnectorConfigGoogleDrive extends Message { + /** + * @generated from field: repeated string include_drive_ids = 2; + */ + includeDriveIds = []; + /** + * @generated from field: repeated string exclude_drive_ids = 3; + */ + excludeDriveIds = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorConfigGoogleDrive'; + static fields = proto3.util.newFieldList(() => [ + { no: 2, name: 'include_drive_ids', kind: 'scalar', T: 9, repeated: true }, + { no: 3, name: 'exclude_drive_ids', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorConfigGoogleDrive().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorConfigGoogleDrive().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorConfigGoogleDrive().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorConfigGoogleDrive, a, b); + } +}; +var ConnectorConfigJira = class _ConnectorConfigJira extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorConfigJira'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _ConnectorConfigJira().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorConfigJira().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorConfigJira().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorConfigJira, a, b); + } +}; +var ConnectorInternalConfig = class _ConnectorInternalConfig extends Message { + /** + * @generated from oneof exa.opensearch_clients_pb.ConnectorInternalConfig.config + */ + config = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorInternalConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'slack', + kind: 'message', + T: ConnectorInternalConfigSlack, + oneof: 'config', + }, + { + no: 2, + name: 'github', + kind: 'message', + T: ConnectorInternalConfigGithub, + oneof: 'config', + }, + { + no: 3, + name: 'google_drive', + kind: 'message', + T: ConnectorInternalConfigGoogleDrive, + oneof: 'config', + }, + { + no: 4, + name: 'jira', + kind: 'message', + T: ConnectorInternalConfigJira, + oneof: 'config', + }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorInternalConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorInternalConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorInternalConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorInternalConfig, a, b); + } +}; +var ConnectorInternalConfigSlack = class _ConnectorInternalConfigSlack extends Message { + /** + * @generated from field: string client_id = 2; + */ + clientId = ''; + /** + * @generated from field: string client_secret = 3; + */ + clientSecret = ''; + /** + * @generated from field: string signing_secret = 1; + */ + signingSecret = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorInternalConfigSlack'; + static fields = proto3.util.newFieldList(() => [ + { + no: 2, + name: 'client_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'client_secret', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 1, + name: 'signing_secret', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorInternalConfigSlack().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorInternalConfigSlack().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorInternalConfigSlack().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorInternalConfigSlack, a, b); + } +}; +var GithubRepoConfig = class _GithubRepoConfig extends Message { + /** + * @generated from field: string organization = 1; + */ + organization = ''; + /** + * @generated from field: string repository = 2; + */ + repository = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.GithubRepoConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'organization', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'repository', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _GithubRepoConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GithubRepoConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GithubRepoConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GithubRepoConfig, a, b); + } +}; +var ConnectorInternalConfigGithub = class _ConnectorInternalConfigGithub extends Message { + /** + * @generated from field: int64 installation_id = 1; + */ + installationId = protoInt64.zero; + /** + * @generated from field: repeated exa.opensearch_clients_pb.GithubRepoConfig repo_configs = 2; + */ + repoConfigs = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorInternalConfigGithub'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'installation_id', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 2, + name: 'repo_configs', + kind: 'message', + T: GithubRepoConfig, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorInternalConfigGithub().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorInternalConfigGithub().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorInternalConfigGithub().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorInternalConfigGithub, a, b); + } +}; +var ConnectorInternalConfigGoogleDrive = class _ConnectorInternalConfigGoogleDrive extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.ConnectorInternalConfigGoogleDrive'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _ConnectorInternalConfigGoogleDrive().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorInternalConfigGoogleDrive().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _ConnectorInternalConfigGoogleDrive().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorInternalConfigGoogleDrive, a, b); + } +}; +var ConnectorInternalConfigJira = class _ConnectorInternalConfigJira extends Message { + /** + * @generated from field: int64 webhook_id = 1; + */ + webhookId = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorInternalConfigJira'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'webhook_id', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorInternalConfigJira().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorInternalConfigJira().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorInternalConfigJira().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorInternalConfigJira, a, b); + } +}; +var ConnectKnowledgeBaseAccountRequest = class _ConnectKnowledgeBaseAccountRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 7; + */ + metadata; + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorType connector = 2; + */ + connector = ConnectorType.UNSPECIFIED; + /** + * @generated from field: string access_token = 3; + */ + accessToken = ''; + /** + * @generated from field: google.protobuf.Timestamp access_token_expires_at = 4; + */ + accessTokenExpiresAt; + /** + * @generated from field: string refresh_token = 5; + */ + refreshToken = ''; + /** + * @generated from field: google.protobuf.Timestamp refresh_token_expires_at = 6; + */ + refreshTokenExpiresAt; + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorAdditionalParams additional_params = 8; + */ + additionalParams; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.ConnectKnowledgeBaseAccountRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 7, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'connector', + kind: 'enum', + T: proto3.getEnumType(ConnectorType), + }, + { + no: 3, + name: 'access_token', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'access_token_expires_at', kind: 'message', T: Timestamp }, + { + no: 5, + name: 'refresh_token', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 6, name: 'refresh_token_expires_at', kind: 'message', T: Timestamp }, + { + no: 8, + name: 'additional_params', + kind: 'message', + T: ConnectorAdditionalParams, + }, + ]); + static fromBinary(bytes, options) { + return new _ConnectKnowledgeBaseAccountRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectKnowledgeBaseAccountRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _ConnectKnowledgeBaseAccountRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ConnectKnowledgeBaseAccountRequest, a, b); + } +}; +var DeleteKnowledgeBaseConnectionRequest = class _DeleteKnowledgeBaseConnectionRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorType connector = 2; + */ + connector = ConnectorType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.DeleteKnowledgeBaseConnectionRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'connector', + kind: 'enum', + T: proto3.getEnumType(ConnectorType), + }, + ]); + static fromBinary(bytes, options) { + return new _DeleteKnowledgeBaseConnectionRequest().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _DeleteKnowledgeBaseConnectionRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _DeleteKnowledgeBaseConnectionRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_DeleteKnowledgeBaseConnectionRequest, a, b); + } +}; +var DeleteKnowledgeBaseConnectionResponse = class _DeleteKnowledgeBaseConnectionResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.DeleteKnowledgeBaseConnectionResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _DeleteKnowledgeBaseConnectionResponse().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _DeleteKnowledgeBaseConnectionResponse().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _DeleteKnowledgeBaseConnectionResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_DeleteKnowledgeBaseConnectionResponse, a, b); + } +}; +var UpdateConnectorConfigRequest = class _UpdateConnectorConfigRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorType connector = 2; + */ + connector = ConnectorType.UNSPECIFIED; + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorConfig config = 3; + */ + config; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.UpdateConnectorConfigRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'connector', + kind: 'enum', + T: proto3.getEnumType(ConnectorType), + }, + { no: 3, name: 'config', kind: 'message', T: ConnectorConfig }, + ]); + static fromBinary(bytes, options) { + return new _UpdateConnectorConfigRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UpdateConnectorConfigRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UpdateConnectorConfigRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_UpdateConnectorConfigRequest, a, b); + } +}; +var UpdateConnectorConfigResponse = class _UpdateConnectorConfigResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.UpdateConnectorConfigResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _UpdateConnectorConfigResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UpdateConnectorConfigResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UpdateConnectorConfigResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_UpdateConnectorConfigResponse, a, b); + } +}; +var ConnectorAdditionalParams = class _ConnectorAdditionalParams extends Message { + /** + * @generated from oneof exa.opensearch_clients_pb.ConnectorAdditionalParams.config + */ + config = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorAdditionalParams'; + static fields = proto3.util.newFieldList(() => [ + { + no: 2, + name: 'slack', + kind: 'message', + T: ConnectorAdditionalParamsSlack, + oneof: 'config', + }, + { + no: 1, + name: 'github', + kind: 'message', + T: ConnectorAdditionalParamsGithub, + oneof: 'config', + }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorAdditionalParams().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorAdditionalParams().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorAdditionalParams().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorAdditionalParams, a, b); + } +}; +var ConnectorAdditionalParamsSlack = class _ConnectorAdditionalParamsSlack extends Message { + /** + * @generated from field: string client_id = 1; + */ + clientId = ''; + /** + * @generated from field: string client_secret = 2; + */ + clientSecret = ''; + /** + * @generated from field: string signing_secret = 3; + */ + signingSecret = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorAdditionalParamsSlack'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'client_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'client_secret', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'signing_secret', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorAdditionalParamsSlack().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorAdditionalParamsSlack().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorAdditionalParamsSlack().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorAdditionalParamsSlack, a, b); + } +}; +var ConnectorAdditionalParamsGithub = class _ConnectorAdditionalParamsGithub extends Message { + /** + * @generated from field: int64 installation_id = 1; + */ + installationId = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorAdditionalParamsGithub'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'installation_id', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorAdditionalParamsGithub().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorAdditionalParamsGithub().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorAdditionalParamsGithub().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorAdditionalParamsGithub, a, b); + } +}; +var ConnectKnowledgeBaseAccountResponse = class _ConnectKnowledgeBaseAccountResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.ConnectKnowledgeBaseAccountResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _ConnectKnowledgeBaseAccountResponse().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _ConnectKnowledgeBaseAccountResponse().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _ConnectKnowledgeBaseAccountResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ConnectKnowledgeBaseAccountResponse, a, b); + } +}; +var CancelKnowledgeBaseJobsRequest = class _CancelKnowledgeBaseJobsRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: repeated int64 job_ids = 2; + */ + jobIds = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.CancelKnowledgeBaseJobsRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { no: 2, name: 'job_ids', kind: 'scalar', T: 3, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _CancelKnowledgeBaseJobsRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CancelKnowledgeBaseJobsRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CancelKnowledgeBaseJobsRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CancelKnowledgeBaseJobsRequest, a, b); + } +}; +var CancelKnowledgeBaseJobsResponse = class _CancelKnowledgeBaseJobsResponse extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.CancelKnowledgeBaseJobsResponse'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CancelKnowledgeBaseJobsResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CancelKnowledgeBaseJobsResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CancelKnowledgeBaseJobsResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CancelKnowledgeBaseJobsResponse, a, b); + } +}; +var DocumentTypeCount = class _DocumentTypeCount extends Message { + /** + * @generated from field: exa.codeium_common_pb.DocumentType document_type = 1; + */ + documentType = DocumentType.UNSPECIFIED; + /** + * @generated from field: int64 count = 2; + */ + count = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.DocumentTypeCount'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'document_type', + kind: 'enum', + T: proto3.getEnumType(DocumentType), + }, + { + no: 2, + name: 'count', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _DocumentTypeCount().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DocumentTypeCount().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DocumentTypeCount().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DocumentTypeCount, a, b); + } +}; +var ConnectorState = class _ConnectorState extends Message { + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorType connector = 1; + */ + connector = ConnectorType.UNSPECIFIED; + /** + * @generated from field: bool initialized = 2; + */ + initialized = false; + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorConfig config = 3; + */ + config; + /** + * @generated from field: repeated exa.opensearch_clients_pb.DocumentTypeCount document_type_counts = 4; + */ + documentTypeCounts = []; + /** + * @generated from field: google.protobuf.Timestamp last_indexed_at = 5; + */ + lastIndexedAt; + /** + * @generated from field: google.protobuf.Timestamp unhealthy_since = 6; + */ + unhealthySince; + /** + * @generated from field: google.protobuf.Timestamp last_configured_at = 7; + */ + lastConfiguredAt; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.ConnectorState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'connector', + kind: 'enum', + T: proto3.getEnumType(ConnectorType), + }, + { + no: 2, + name: 'initialized', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 3, name: 'config', kind: 'message', T: ConnectorConfig }, + { + no: 4, + name: 'document_type_counts', + kind: 'message', + T: DocumentTypeCount, + repeated: true, + }, + { no: 5, name: 'last_indexed_at', kind: 'message', T: Timestamp }, + { no: 6, name: 'unhealthy_since', kind: 'message', T: Timestamp }, + { no: 7, name: 'last_configured_at', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _ConnectorState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConnectorState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConnectorState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConnectorState, a, b); + } +}; +var GetKnowledgeBaseConnectorStateRequest = class _GetKnowledgeBaseConnectorStateRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetKnowledgeBaseConnectorStateRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + ]); + static fromBinary(bytes, options) { + return new _GetKnowledgeBaseConnectorStateRequest().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _GetKnowledgeBaseConnectorStateRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetKnowledgeBaseConnectorStateRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetKnowledgeBaseConnectorStateRequest, a, b); + } +}; +var GetKnowledgeBaseConnectorStateResponse = class _GetKnowledgeBaseConnectorStateResponse extends Message { + /** + * @generated from field: repeated exa.opensearch_clients_pb.ConnectorState connector_states = 1; + */ + connectorStates = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetKnowledgeBaseConnectorStateResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'connector_states', + kind: 'message', + T: ConnectorState, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetKnowledgeBaseConnectorStateResponse().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _GetKnowledgeBaseConnectorStateResponse().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetKnowledgeBaseConnectorStateResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetKnowledgeBaseConnectorStateResponse, a, b); + } +}; +var JobState = class _JobState extends Message { + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorType connector = 1; + */ + connector = ConnectorType.UNSPECIFIED; + /** + * @generated from field: int64 id = 2; + */ + id = protoInt64.zero; + /** + * @generated from field: exa.opensearch_clients_pb.JobStatus status = 3; + */ + status = JobStatus.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.JobState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'connector', + kind: 'enum', + T: proto3.getEnumType(ConnectorType), + }, + { + no: 2, + name: 'id', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { no: 3, name: 'status', kind: 'enum', T: proto3.getEnumType(JobStatus) }, + ]); + static fromBinary(bytes, options) { + return new _JobState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _JobState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _JobState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_JobState, a, b); + } +}; +var GetKnowledgeBaseJobStatesRequest = class _GetKnowledgeBaseJobStatesRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + /** + * @generated from field: repeated exa.opensearch_clients_pb.ConnectorType connector_types = 2; + */ + connectorTypes = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetKnowledgeBaseJobStatesRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + { + no: 2, + name: 'connector_types', + kind: 'enum', + T: proto3.getEnumType(ConnectorType), + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GetKnowledgeBaseJobStatesRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetKnowledgeBaseJobStatesRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GetKnowledgeBaseJobStatesRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetKnowledgeBaseJobStatesRequest, a, b); + } +}; +var GetKnowledgeBaseJobStatesResponse = class _GetKnowledgeBaseJobStatesResponse extends Message { + /** + * @generated from field: repeated exa.opensearch_clients_pb.JobState job_states = 1; + */ + jobStates = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetKnowledgeBaseJobStatesResponse'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'job_states', kind: 'message', T: JobState, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _GetKnowledgeBaseJobStatesResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetKnowledgeBaseJobStatesResponse().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetKnowledgeBaseJobStatesResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetKnowledgeBaseJobStatesResponse, a, b); + } +}; +var SlackMessagePayload = class _SlackMessagePayload extends Message { + /** + * TODO(saujasn): Move this metadata into an eval specific proto (in + * exa/beacon_eval). Our metadata + * + * Format: + * + * @generated from field: string dataset_id = 1; + */ + datasetId = ''; + /** + * Slack:[VERSION]:[CONVERSATION_ID]:[POSITION_IN_CONVERSATION]:[POSITION_IN_THREAD] + * + * empty string if the previous message is not in the dataset + * + * @generated from field: string previous_message_dataset_id = 2; + */ + previousMessageDatasetId = ''; + /** + * Slack data + * We intentionally do not use strong types for these fields. + * One reason is that we need to ensure that we're accepting all data + * we receive, for our reindexing/backup systems to be lossless. + * Validation should instead be done after loading this data, and before + * insertion into OpenSearch. + * + * @generated from field: string type = 3; + */ + type = ''; + /** + * @generated from field: string channel_id = 4; + */ + channelId = ''; + /** + * @generated from field: string user = 5; + */ + user = ''; + /** + * @generated from field: string text = 6; + */ + text = ''; + /** + * @generated from field: string timestamp = 7; + */ + timestamp = ''; + /** + * @generated from field: string thread_timestamp = 8; + */ + threadTimestamp = ''; + /** + * @generated from field: string channel_name = 9; + */ + channelName = ''; + /** + * @generated from field: string team_name = 10; + */ + teamName = ''; + /** + * @generated from field: string team_id = 11; + */ + teamId = ''; + /** + * @generated from field: bool is_private_channel = 12; + */ + isPrivateChannel = false; + /** + * @generated from field: string team_domain = 13; + */ + teamDomain = ''; + /** + * @generated from field: string original_timestamp = 14; + */ + originalTimestamp = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.SlackMessagePayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'dataset_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'previous_message_dataset_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'channel_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'user', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'timestamp', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'thread_timestamp', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'channel_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'team_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 11, + name: 'team_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'is_private_channel', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 13, + name: 'team_domain', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 14, + name: 'original_timestamp', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _SlackMessagePayload().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SlackMessagePayload().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SlackMessagePayload().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SlackMessagePayload, a, b); + } +}; +var SlackChannelPayload = class _SlackChannelPayload extends Message { + /** + * @generated from field: string type = 1; + */ + type = ''; + /** + * @generated from field: string channel_id = 2; + */ + channelId = ''; + /** + * @generated from field: string channel_name = 4; + */ + channelName = ''; + /** + * @generated from field: string description = 7; + */ + description = ''; + /** + * @generated from field: string team_id = 8; + */ + teamId = ''; + /** + * @generated from field: bool is_private_channel = 9; + */ + isPrivateChannel = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.SlackChannelPayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'channel_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'channel_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'team_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'is_private_channel', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _SlackChannelPayload().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SlackChannelPayload().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SlackChannelPayload().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SlackChannelPayload, a, b); + } +}; +var SlackPayload = class _SlackPayload extends Message { + /** + * @generated from oneof exa.opensearch_clients_pb.SlackPayload.payload + */ + payload = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.opensearch_clients_pb.SlackPayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 13, + name: 'message', + kind: 'message', + T: SlackMessagePayload, + oneof: 'payload', + }, + { + no: 14, + name: 'channel', + kind: 'message', + T: SlackChannelPayload, + oneof: 'payload', + }, + ]); + static fromBinary(bytes, options) { + return new _SlackPayload().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SlackPayload().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SlackPayload().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SlackPayload, a, b); + } +}; +var GetKnowledgeBaseWebhookUrlRequest = class _GetKnowledgeBaseWebhookUrlRequest extends Message { + /** + * @generated from field: exa.index_pb.ManagementMetadata metadata = 1; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetKnowledgeBaseWebhookUrlRequest'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: ManagementMetadata }, + ]); + static fromBinary(bytes, options) { + return new _GetKnowledgeBaseWebhookUrlRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetKnowledgeBaseWebhookUrlRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetKnowledgeBaseWebhookUrlRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetKnowledgeBaseWebhookUrlRequest, a, b); + } +}; +var GetKnowledgeBaseWebhookUrlResponse = class _GetKnowledgeBaseWebhookUrlResponse extends Message { + /** + * @generated from field: string webhook_url = 1; + */ + webhookUrl = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetKnowledgeBaseWebhookUrlResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'webhook_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _GetKnowledgeBaseWebhookUrlResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetKnowledgeBaseWebhookUrlResponse().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetKnowledgeBaseWebhookUrlResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetKnowledgeBaseWebhookUrlResponse, a, b); + } +}; +var GetConnectorInternalConfigRequest = class _GetConnectorInternalConfigRequest extends Message { + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorType connector = 1; + */ + connector = ConnectorType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetConnectorInternalConfigRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'connector', + kind: 'enum', + T: proto3.getEnumType(ConnectorType), + }, + ]); + static fromBinary(bytes, options) { + return new _GetConnectorInternalConfigRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetConnectorInternalConfigRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetConnectorInternalConfigRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetConnectorInternalConfigRequest, a, b); + } +}; +var GetConnectorInternalConfigResponse = class _GetConnectorInternalConfigResponse extends Message { + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorInternalConfig internal_config = 1; + */ + internalConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.opensearch_clients_pb.GetConnectorInternalConfigResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'internal_config', + kind: 'message', + T: ConnectorInternalConfig, + }, + ]); + static fromBinary(bytes, options) { + return new _GetConnectorInternalConfigResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GetConnectorInternalConfigResponse().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _GetConnectorInternalConfigResponse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_GetConnectorInternalConfigResponse, a, b); + } +}; + +// exa/proto_ts/dist/exa/browser_pb/browser_pb.js +var ClickType; +(function (ClickType2) { + ClickType2[(ClickType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ClickType2[(ClickType2['LEFT'] = 1)] = 'LEFT'; + ClickType2[(ClickType2['RIGHT'] = 2)] = 'RIGHT'; + ClickType2[(ClickType2['DOUBLE'] = 3)] = 'DOUBLE'; + ClickType2[(ClickType2['NONE'] = 4)] = 'NONE'; +})(ClickType || (ClickType = {})); +proto3.util.setEnumType(ClickType, 'exa.browser_pb.ClickType', [ + { no: 0, name: 'CLICK_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CLICK_TYPE_LEFT' }, + { no: 2, name: 'CLICK_TYPE_RIGHT' }, + { no: 3, name: 'CLICK_TYPE_DOUBLE' }, + { no: 4, name: 'CLICK_TYPE_NONE' }, +]); +var ScrollDirection; +(function (ScrollDirection2) { + ScrollDirection2[(ScrollDirection2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ScrollDirection2[(ScrollDirection2['UP'] = 1)] = 'UP'; + ScrollDirection2[(ScrollDirection2['DOWN'] = 2)] = 'DOWN'; + ScrollDirection2[(ScrollDirection2['LEFT'] = 3)] = 'LEFT'; + ScrollDirection2[(ScrollDirection2['RIGHT'] = 4)] = 'RIGHT'; +})(ScrollDirection || (ScrollDirection = {})); +proto3.util.setEnumType(ScrollDirection, 'exa.browser_pb.ScrollDirection', [ + { no: 0, name: 'SCROLL_DIRECTION_UNSPECIFIED' }, + { no: 1, name: 'SCROLL_DIRECTION_UP' }, + { no: 2, name: 'SCROLL_DIRECTION_DOWN' }, + { no: 3, name: 'SCROLL_DIRECTION_LEFT' }, + { no: 4, name: 'SCROLL_DIRECTION_RIGHT' }, +]); +var WindowState; +(function (WindowState2) { + WindowState2[(WindowState2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + WindowState2[(WindowState2['NORMAL'] = 1)] = 'NORMAL'; + WindowState2[(WindowState2['MINIMIZED'] = 2)] = 'MINIMIZED'; + WindowState2[(WindowState2['MAXIMIZED'] = 3)] = 'MAXIMIZED'; + WindowState2[(WindowState2['FULLSCREEN'] = 4)] = 'FULLSCREEN'; +})(WindowState || (WindowState = {})); +proto3.util.setEnumType(WindowState, 'exa.browser_pb.WindowState', [ + { no: 0, name: 'WINDOW_STATE_UNSPECIFIED' }, + { no: 1, name: 'WINDOW_STATE_NORMAL' }, + { no: 2, name: 'WINDOW_STATE_MINIMIZED' }, + { no: 3, name: 'WINDOW_STATE_MAXIMIZED' }, + { no: 4, name: 'WINDOW_STATE_FULLSCREEN' }, +]); +var SerializablePageState = class _SerializablePageState extends Message { + /** + * CDP page identifier. + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata metadata = 2; + */ + metadata; + /** + * @generated from field: exa.codeium_common_pb.DOMTree dom_tree = 3; + */ + domTree; + /** + * @generated from field: exa.codeium_common_pb.ImageData screenshot = 4 [deprecated = true]; + * @deprecated + */ + screenshot; + /** + * @generated from field: exa.browser_pb.AgentMousePosition agent_mouse_position = 5; + */ + agentMousePosition; + /** + * @generated from field: exa.codeium_common_pb.ConsoleLogScopeItem console_logs = 6; + */ + consoleLogs; + /** + * @generated from field: google.protobuf.Timestamp added_time = 7; + */ + addedTime; + /** + * @generated from field: string serialized_dom_tree = 8; + */ + serializedDomTree = ''; + /** + * @generated from field: exa.codeium_common_pb.Media media_screenshot = 9; + */ + mediaScreenshot; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.browser_pb.SerializablePageState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'metadata', kind: 'message', T: BrowserPageMetadata }, + { no: 3, name: 'dom_tree', kind: 'message', T: DOMTree }, + { no: 4, name: 'screenshot', kind: 'message', T: ImageData }, + { + no: 5, + name: 'agent_mouse_position', + kind: 'message', + T: AgentMousePosition, + }, + { no: 6, name: 'console_logs', kind: 'message', T: ConsoleLogScopeItem }, + { no: 7, name: 'added_time', kind: 'message', T: Timestamp }, + { + no: 8, + name: 'serialized_dom_tree', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 9, name: 'media_screenshot', kind: 'message', T: Media }, + ]); + static fromBinary(bytes, options) { + return new _SerializablePageState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SerializablePageState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SerializablePageState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SerializablePageState, a, b); + } +}; +var AgentMousePosition = class _AgentMousePosition extends Message { + /** + * @generated from field: int32 x = 1; + */ + x = 0; + /** + * @generated from field: int32 y = 2; + */ + y = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.browser_pb.AgentMousePosition'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'x', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'y', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _AgentMousePosition().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AgentMousePosition().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AgentMousePosition().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AgentMousePosition, a, b); + } +}; + +// exa/proto_ts/dist/exa/cortex_pb/cortex_pb.js +var InteractiveCascadeEditImportance; +(function (InteractiveCascadeEditImportance2) { + InteractiveCascadeEditImportance2[ + (InteractiveCascadeEditImportance2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + InteractiveCascadeEditImportance2[ + (InteractiveCascadeEditImportance2['LOW'] = 1) + ] = 'LOW'; + InteractiveCascadeEditImportance2[ + (InteractiveCascadeEditImportance2['MEDIUM'] = 2) + ] = 'MEDIUM'; + InteractiveCascadeEditImportance2[ + (InteractiveCascadeEditImportance2['HIGH'] = 3) + ] = 'HIGH'; +})(InteractiveCascadeEditImportance || (InteractiveCascadeEditImportance = {})); +proto3.util.setEnumType( + InteractiveCascadeEditImportance, + 'exa.cortex_pb.InteractiveCascadeEditImportance', + [ + { no: 0, name: 'INTERACTIVE_CASCADE_EDIT_IMPORTANCE_UNSPECIFIED' }, + { no: 1, name: 'INTERACTIVE_CASCADE_EDIT_IMPORTANCE_LOW' }, + { no: 2, name: 'INTERACTIVE_CASCADE_EDIT_IMPORTANCE_MEDIUM' }, + { no: 3, name: 'INTERACTIVE_CASCADE_EDIT_IMPORTANCE_HIGH' }, + ], +); +var ActionStatus; +(function (ActionStatus2) { + ActionStatus2[(ActionStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ActionStatus2[(ActionStatus2['ERROR'] = 1)] = 'ERROR'; + ActionStatus2[(ActionStatus2['INITIALIZED'] = 2)] = 'INITIALIZED'; + ActionStatus2[(ActionStatus2['PREPARING'] = 3)] = 'PREPARING'; + ActionStatus2[(ActionStatus2['PREPARED'] = 4)] = 'PREPARED'; + ActionStatus2[(ActionStatus2['APPLYING'] = 5)] = 'APPLYING'; + ActionStatus2[(ActionStatus2['APPLIED'] = 6)] = 'APPLIED'; + ActionStatus2[(ActionStatus2['REJECTED'] = 7)] = 'REJECTED'; +})(ActionStatus || (ActionStatus = {})); +proto3.util.setEnumType(ActionStatus, 'exa.cortex_pb.ActionStatus', [ + { no: 0, name: 'ACTION_STATUS_UNSPECIFIED' }, + { no: 1, name: 'ACTION_STATUS_ERROR' }, + { no: 2, name: 'ACTION_STATUS_INITIALIZED' }, + { no: 3, name: 'ACTION_STATUS_PREPARING' }, + { no: 4, name: 'ACTION_STATUS_PREPARED' }, + { no: 5, name: 'ACTION_STATUS_APPLYING' }, + { no: 6, name: 'ACTION_STATUS_APPLIED' }, + { no: 7, name: 'ACTION_STATUS_REJECTED' }, +]); +var PlanStatus2; +(function (PlanStatus3) { + PlanStatus3[(PlanStatus3['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + PlanStatus3[(PlanStatus3['INITIALIZED'] = 1)] = 'INITIALIZED'; + PlanStatus3[(PlanStatus3['PLANNING'] = 2)] = 'PLANNING'; + PlanStatus3[(PlanStatus3['PLANNED'] = 3)] = 'PLANNED'; + PlanStatus3[(PlanStatus3['ERROR'] = 4)] = 'ERROR'; +})(PlanStatus2 || (PlanStatus2 = {})); +proto3.util.setEnumType(PlanStatus2, 'exa.cortex_pb.PlanStatus', [ + { no: 0, name: 'PLAN_STATUS_UNSPECIFIED' }, + { no: 1, name: 'PLAN_STATUS_INITIALIZED' }, + { no: 2, name: 'PLAN_STATUS_PLANNING' }, + { no: 3, name: 'PLAN_STATUS_PLANNED' }, + { no: 4, name: 'PLAN_STATUS_ERROR' }, +]); +var CortexRequestSource; +(function (CortexRequestSource2) { + CortexRequestSource2[(CortexRequestSource2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CortexRequestSource2[(CortexRequestSource2['CASCADE'] = 1)] = 'CASCADE'; + CortexRequestSource2[(CortexRequestSource2['USER_IMPLICIT'] = 2)] = + 'USER_IMPLICIT'; +})(CortexRequestSource || (CortexRequestSource = {})); +proto3.util.setEnumType( + CortexRequestSource, + 'exa.cortex_pb.CortexRequestSource', + [ + { no: 0, name: 'CORTEX_REQUEST_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_REQUEST_SOURCE_CASCADE' }, + { no: 2, name: 'CORTEX_REQUEST_SOURCE_USER_IMPLICIT' }, + ], +); +var WorkspaceType; +(function (WorkspaceType2) { + WorkspaceType2[(WorkspaceType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + WorkspaceType2[(WorkspaceType2['GIT'] = 1)] = 'GIT'; + WorkspaceType2[(WorkspaceType2['PIPER'] = 2)] = 'PIPER'; + WorkspaceType2[(WorkspaceType2['FIG'] = 3)] = 'FIG'; + WorkspaceType2[(WorkspaceType2['JJ_PIPER'] = 4)] = 'JJ_PIPER'; + WorkspaceType2[(WorkspaceType2['JJ_GIT'] = 5)] = 'JJ_GIT'; +})(WorkspaceType || (WorkspaceType = {})); +proto3.util.setEnumType(WorkspaceType, 'exa.cortex_pb.WorkspaceType', [ + { no: 0, name: 'WORKSPACE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'WORKSPACE_TYPE_GIT' }, + { no: 2, name: 'WORKSPACE_TYPE_PIPER' }, + { no: 3, name: 'WORKSPACE_TYPE_FIG' }, + { no: 4, name: 'WORKSPACE_TYPE_JJ_PIPER' }, + { no: 5, name: 'WORKSPACE_TYPE_JJ_GIT' }, +]); +var CortexTrajectorySource; +(function (CortexTrajectorySource2) { + CortexTrajectorySource2[(CortexTrajectorySource2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CortexTrajectorySource2[(CortexTrajectorySource2['CASCADE_CLIENT'] = 1)] = + 'CASCADE_CLIENT'; + CortexTrajectorySource2[(CortexTrajectorySource2['EXPLAIN_PROBLEM'] = 2)] = + 'EXPLAIN_PROBLEM'; + CortexTrajectorySource2[(CortexTrajectorySource2['REFACTOR_FUNCTION'] = 3)] = + 'REFACTOR_FUNCTION'; + CortexTrajectorySource2[(CortexTrajectorySource2['EVAL'] = 4)] = 'EVAL'; + CortexTrajectorySource2[(CortexTrajectorySource2['EVAL_TASK'] = 5)] = + 'EVAL_TASK'; + CortexTrajectorySource2[(CortexTrajectorySource2['ASYNC_PRR'] = 6)] = + 'ASYNC_PRR'; + CortexTrajectorySource2[(CortexTrajectorySource2['ASYNC_CF'] = 7)] = + 'ASYNC_CF'; + CortexTrajectorySource2[(CortexTrajectorySource2['ASYNC_SL'] = 8)] = + 'ASYNC_SL'; + CortexTrajectorySource2[(CortexTrajectorySource2['ASYNC_PRD'] = 9)] = + 'ASYNC_PRD'; + CortexTrajectorySource2[(CortexTrajectorySource2['ASYNC_CM'] = 10)] = + 'ASYNC_CM'; + CortexTrajectorySource2[ + (CortexTrajectorySource2['INTERACTIVE_CASCADE'] = 12) + ] = 'INTERACTIVE_CASCADE'; + CortexTrajectorySource2[(CortexTrajectorySource2['REPLAY'] = 13)] = 'REPLAY'; + CortexTrajectorySource2[(CortexTrajectorySource2['SDK'] = 15)] = 'SDK'; +})(CortexTrajectorySource || (CortexTrajectorySource = {})); +proto3.util.setEnumType( + CortexTrajectorySource, + 'exa.cortex_pb.CortexTrajectorySource', + [ + { no: 0, name: 'CORTEX_TRAJECTORY_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_TRAJECTORY_SOURCE_CASCADE_CLIENT' }, + { no: 2, name: 'CORTEX_TRAJECTORY_SOURCE_EXPLAIN_PROBLEM' }, + { no: 3, name: 'CORTEX_TRAJECTORY_SOURCE_REFACTOR_FUNCTION' }, + { no: 4, name: 'CORTEX_TRAJECTORY_SOURCE_EVAL' }, + { no: 5, name: 'CORTEX_TRAJECTORY_SOURCE_EVAL_TASK' }, + { no: 6, name: 'CORTEX_TRAJECTORY_SOURCE_ASYNC_PRR' }, + { no: 7, name: 'CORTEX_TRAJECTORY_SOURCE_ASYNC_CF' }, + { no: 8, name: 'CORTEX_TRAJECTORY_SOURCE_ASYNC_SL' }, + { no: 9, name: 'CORTEX_TRAJECTORY_SOURCE_ASYNC_PRD' }, + { no: 10, name: 'CORTEX_TRAJECTORY_SOURCE_ASYNC_CM' }, + { no: 12, name: 'CORTEX_TRAJECTORY_SOURCE_INTERACTIVE_CASCADE' }, + { no: 13, name: 'CORTEX_TRAJECTORY_SOURCE_REPLAY' }, + { no: 15, name: 'CORTEX_TRAJECTORY_SOURCE_SDK' }, + ], +); +var CortexTrajectoryType; +(function (CortexTrajectoryType2) { + CortexTrajectoryType2[(CortexTrajectoryType2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CortexTrajectoryType2[(CortexTrajectoryType2['USER_MAINLINE'] = 1)] = + 'USER_MAINLINE'; + CortexTrajectoryType2[(CortexTrajectoryType2['USER_GRANULAR'] = 2)] = + 'USER_GRANULAR'; + CortexTrajectoryType2[(CortexTrajectoryType2['SUPERCOMPLETE'] = 3)] = + 'SUPERCOMPLETE'; + CortexTrajectoryType2[(CortexTrajectoryType2['CASCADE'] = 4)] = 'CASCADE'; + CortexTrajectoryType2[(CortexTrajectoryType2['CHECKPOINT'] = 6)] = + 'CHECKPOINT'; + CortexTrajectoryType2[(CortexTrajectoryType2['APPLIER'] = 11)] = 'APPLIER'; + CortexTrajectoryType2[(CortexTrajectoryType2['TOOL_CALL_PROPOSAL'] = 12)] = + 'TOOL_CALL_PROPOSAL'; + CortexTrajectoryType2[(CortexTrajectoryType2['TRAJECTORY_CHOICE'] = 13)] = + 'TRAJECTORY_CHOICE'; + CortexTrajectoryType2[(CortexTrajectoryType2['LLM_JUDGE'] = 14)] = + 'LLM_JUDGE'; + CortexTrajectoryType2[(CortexTrajectoryType2['INTERACTIVE_CASCADE'] = 17)] = + 'INTERACTIVE_CASCADE'; + CortexTrajectoryType2[(CortexTrajectoryType2['BRAIN_UPDATE'] = 16)] = + 'BRAIN_UPDATE'; + CortexTrajectoryType2[(CortexTrajectoryType2['BROWSER'] = 20)] = 'BROWSER'; + CortexTrajectoryType2[(CortexTrajectoryType2['KNOWLEDGE_GENERATION'] = 21)] = + 'KNOWLEDGE_GENERATION'; +})(CortexTrajectoryType || (CortexTrajectoryType = {})); +proto3.util.setEnumType( + CortexTrajectoryType, + 'exa.cortex_pb.CortexTrajectoryType', + [ + { no: 0, name: 'CORTEX_TRAJECTORY_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_TRAJECTORY_TYPE_USER_MAINLINE' }, + { no: 2, name: 'CORTEX_TRAJECTORY_TYPE_USER_GRANULAR' }, + { no: 3, name: 'CORTEX_TRAJECTORY_TYPE_SUPERCOMPLETE' }, + { no: 4, name: 'CORTEX_TRAJECTORY_TYPE_CASCADE' }, + { no: 6, name: 'CORTEX_TRAJECTORY_TYPE_CHECKPOINT' }, + { no: 11, name: 'CORTEX_TRAJECTORY_TYPE_APPLIER' }, + { no: 12, name: 'CORTEX_TRAJECTORY_TYPE_TOOL_CALL_PROPOSAL' }, + { no: 13, name: 'CORTEX_TRAJECTORY_TYPE_TRAJECTORY_CHOICE' }, + { no: 14, name: 'CORTEX_TRAJECTORY_TYPE_LLM_JUDGE' }, + { no: 17, name: 'CORTEX_TRAJECTORY_TYPE_INTERACTIVE_CASCADE' }, + { no: 16, name: 'CORTEX_TRAJECTORY_TYPE_BRAIN_UPDATE' }, + { no: 20, name: 'CORTEX_TRAJECTORY_TYPE_BROWSER' }, + { no: 21, name: 'CORTEX_TRAJECTORY_TYPE_KNOWLEDGE_GENERATION' }, + ], +); +var CortexTrajectoryReferenceType; +(function (CortexTrajectoryReferenceType2) { + CortexTrajectoryReferenceType2[ + (CortexTrajectoryReferenceType2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + CortexTrajectoryReferenceType2[ + (CortexTrajectoryReferenceType2['PRUNE'] = 1) + ] = 'PRUNE'; + CortexTrajectoryReferenceType2[(CortexTrajectoryReferenceType2['FORK'] = 2)] = + 'FORK'; +})(CortexTrajectoryReferenceType || (CortexTrajectoryReferenceType = {})); +proto3.util.setEnumType( + CortexTrajectoryReferenceType, + 'exa.cortex_pb.CortexTrajectoryReferenceType', + [ + { no: 0, name: 'CORTEX_TRAJECTORY_REFERENCE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_TRAJECTORY_REFERENCE_TYPE_PRUNE' }, + { no: 2, name: 'CORTEX_TRAJECTORY_REFERENCE_TYPE_FORK' }, + ], +); +var RetryReason; +(function (RetryReason2) { + RetryReason2[(RetryReason2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + RetryReason2[(RetryReason2['API_RETRYABLE'] = 1)] = 'API_RETRYABLE'; + RetryReason2[(RetryReason2['MODEL_CORRECTABLE'] = 2)] = 'MODEL_CORRECTABLE'; + RetryReason2[(RetryReason2['NON_RECOVERABLE'] = 3)] = 'NON_RECOVERABLE'; +})(RetryReason || (RetryReason = {})); +proto3.util.setEnumType(RetryReason, 'exa.cortex_pb.RetryReason', [ + { no: 0, name: 'RETRY_REASON_UNSPECIFIED' }, + { no: 1, name: 'RETRY_REASON_API_RETRYABLE' }, + { no: 2, name: 'RETRY_REASON_MODEL_CORRECTABLE' }, + { no: 3, name: 'RETRY_REASON_NON_RECOVERABLE' }, +]); +var TruncationReason; +(function (TruncationReason2) { + TruncationReason2[(TruncationReason2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + TruncationReason2[(TruncationReason2['PROMPT_CACHE_TTL_EXPIRED'] = 1)] = + 'PROMPT_CACHE_TTL_EXPIRED'; + TruncationReason2[(TruncationReason2['MAX_TOKEN_LIMIT'] = 2)] = + 'MAX_TOKEN_LIMIT'; +})(TruncationReason || (TruncationReason = {})); +proto3.util.setEnumType(TruncationReason, 'exa.cortex_pb.TruncationReason', [ + { no: 0, name: 'TRUNCATION_REASON_UNSPECIFIED' }, + { no: 1, name: 'TRUNCATION_REASON_PROMPT_CACHE_TTL_EXPIRED' }, + { no: 2, name: 'TRUNCATION_REASON_MAX_TOKEN_LIMIT' }, +]); +var CortexStepSource; +(function (CortexStepSource2) { + CortexStepSource2[(CortexStepSource2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CortexStepSource2[(CortexStepSource2['MODEL'] = 2)] = 'MODEL'; + CortexStepSource2[(CortexStepSource2['USER_IMPLICIT'] = 3)] = 'USER_IMPLICIT'; + CortexStepSource2[(CortexStepSource2['USER_EXPLICIT'] = 4)] = 'USER_EXPLICIT'; + CortexStepSource2[(CortexStepSource2['SYSTEM'] = 5)] = 'SYSTEM'; + CortexStepSource2[(CortexStepSource2['SYSTEM_SDK'] = 6)] = 'SYSTEM_SDK'; +})(CortexStepSource || (CortexStepSource = {})); +proto3.util.setEnumType(CortexStepSource, 'exa.cortex_pb.CortexStepSource', [ + { no: 0, name: 'CORTEX_STEP_SOURCE_UNSPECIFIED' }, + { no: 2, name: 'CORTEX_STEP_SOURCE_MODEL' }, + { no: 3, name: 'CORTEX_STEP_SOURCE_USER_IMPLICIT' }, + { no: 4, name: 'CORTEX_STEP_SOURCE_USER_EXPLICIT' }, + { no: 5, name: 'CORTEX_STEP_SOURCE_SYSTEM' }, + { no: 6, name: 'CORTEX_STEP_SOURCE_SYSTEM_SDK' }, +]); +var CortexStepCreditReason; +(function (CortexStepCreditReason2) { + CortexStepCreditReason2[(CortexStepCreditReason2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CortexStepCreditReason2[ + (CortexStepCreditReason2['LINT_FIXING_DISCOUNT'] = 1) + ] = 'LINT_FIXING_DISCOUNT'; +})(CortexStepCreditReason || (CortexStepCreditReason = {})); +proto3.util.setEnumType( + CortexStepCreditReason, + 'exa.cortex_pb.CortexStepCreditReason', + [ + { no: 0, name: 'CORTEX_STEP_CREDIT_REASON_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_STEP_CREDIT_REASON_LINT_FIXING_DISCOUNT' }, + ], +); +var ExecutionAsyncLevel; +(function (ExecutionAsyncLevel2) { + ExecutionAsyncLevel2[(ExecutionAsyncLevel2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + ExecutionAsyncLevel2[(ExecutionAsyncLevel2['INVOCATION_BLOCKING'] = 1)] = + 'INVOCATION_BLOCKING'; + ExecutionAsyncLevel2[(ExecutionAsyncLevel2['EXECUTOR_BLOCKING'] = 2)] = + 'EXECUTOR_BLOCKING'; + ExecutionAsyncLevel2[(ExecutionAsyncLevel2['FULL_ASYNC'] = 3)] = 'FULL_ASYNC'; +})(ExecutionAsyncLevel || (ExecutionAsyncLevel = {})); +proto3.util.setEnumType( + ExecutionAsyncLevel, + 'exa.cortex_pb.ExecutionAsyncLevel', + [ + { no: 0, name: 'EXECUTION_ASYNC_LEVEL_UNSPECIFIED' }, + { no: 1, name: 'EXECUTION_ASYNC_LEVEL_INVOCATION_BLOCKING' }, + { no: 2, name: 'EXECUTION_ASYNC_LEVEL_EXECUTOR_BLOCKING' }, + { no: 3, name: 'EXECUTION_ASYNC_LEVEL_FULL_ASYNC' }, + ], +); +var CortexStepStatus; +(function (CortexStepStatus2) { + CortexStepStatus2[(CortexStepStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CortexStepStatus2[(CortexStepStatus2['GENERATING'] = 8)] = 'GENERATING'; + CortexStepStatus2[(CortexStepStatus2['QUEUED'] = 11)] = 'QUEUED'; + CortexStepStatus2[(CortexStepStatus2['PENDING'] = 1)] = 'PENDING'; + CortexStepStatus2[(CortexStepStatus2['RUNNING'] = 2)] = 'RUNNING'; + CortexStepStatus2[(CortexStepStatus2['WAITING'] = 9)] = 'WAITING'; + CortexStepStatus2[(CortexStepStatus2['DONE'] = 3)] = 'DONE'; + CortexStepStatus2[(CortexStepStatus2['INVALID'] = 4)] = 'INVALID'; + CortexStepStatus2[(CortexStepStatus2['CLEARED'] = 5)] = 'CLEARED'; + CortexStepStatus2[(CortexStepStatus2['CANCELED'] = 6)] = 'CANCELED'; + CortexStepStatus2[(CortexStepStatus2['ERROR'] = 7)] = 'ERROR'; + CortexStepStatus2[(CortexStepStatus2['INTERRUPTED'] = 12)] = 'INTERRUPTED'; +})(CortexStepStatus || (CortexStepStatus = {})); +proto3.util.setEnumType(CortexStepStatus, 'exa.cortex_pb.CortexStepStatus', [ + { no: 0, name: 'CORTEX_STEP_STATUS_UNSPECIFIED' }, + { no: 8, name: 'CORTEX_STEP_STATUS_GENERATING' }, + { no: 11, name: 'CORTEX_STEP_STATUS_QUEUED' }, + { no: 1, name: 'CORTEX_STEP_STATUS_PENDING' }, + { no: 2, name: 'CORTEX_STEP_STATUS_RUNNING' }, + { no: 9, name: 'CORTEX_STEP_STATUS_WAITING' }, + { no: 3, name: 'CORTEX_STEP_STATUS_DONE' }, + { no: 4, name: 'CORTEX_STEP_STATUS_INVALID' }, + { no: 5, name: 'CORTEX_STEP_STATUS_CLEARED' }, + { no: 6, name: 'CORTEX_STEP_STATUS_CANCELED' }, + { no: 7, name: 'CORTEX_STEP_STATUS_ERROR' }, + { no: 12, name: 'CORTEX_STEP_STATUS_INTERRUPTED' }, +]); +var CascadeRunStatus; +(function (CascadeRunStatus2) { + CascadeRunStatus2[(CascadeRunStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CascadeRunStatus2[(CascadeRunStatus2['IDLE'] = 1)] = 'IDLE'; + CascadeRunStatus2[(CascadeRunStatus2['RUNNING'] = 2)] = 'RUNNING'; + CascadeRunStatus2[(CascadeRunStatus2['CANCELING'] = 3)] = 'CANCELING'; + CascadeRunStatus2[(CascadeRunStatus2['BUSY'] = 4)] = 'BUSY'; +})(CascadeRunStatus || (CascadeRunStatus = {})); +proto3.util.setEnumType(CascadeRunStatus, 'exa.cortex_pb.CascadeRunStatus', [ + { no: 0, name: 'CASCADE_RUN_STATUS_UNSPECIFIED' }, + { no: 1, name: 'CASCADE_RUN_STATUS_IDLE' }, + { no: 2, name: 'CASCADE_RUN_STATUS_RUNNING' }, + { no: 3, name: 'CASCADE_RUN_STATUS_CANCELING' }, + { no: 4, name: 'CASCADE_RUN_STATUS_BUSY' }, +]); +var BrainFilterStrategy; +(function (BrainFilterStrategy2) { + BrainFilterStrategy2[(BrainFilterStrategy2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + BrainFilterStrategy2[(BrainFilterStrategy2['NO_SYSTEM_INJECTED_STEPS'] = 1)] = + 'NO_SYSTEM_INJECTED_STEPS'; + BrainFilterStrategy2[(BrainFilterStrategy2['NO_MEMORIES'] = 2)] = + 'NO_MEMORIES'; +})(BrainFilterStrategy || (BrainFilterStrategy = {})); +proto3.util.setEnumType( + BrainFilterStrategy, + 'exa.cortex_pb.BrainFilterStrategy', + [ + { no: 0, name: 'BRAIN_FILTER_STRATEGY_UNSPECIFIED' }, + { no: 1, name: 'BRAIN_FILTER_STRATEGY_NO_SYSTEM_INJECTED_STEPS' }, + { no: 2, name: 'BRAIN_FILTER_STRATEGY_NO_MEMORIES' }, + ], +); +var SectionOverrideMode; +(function (SectionOverrideMode2) { + SectionOverrideMode2[(SectionOverrideMode2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + SectionOverrideMode2[(SectionOverrideMode2['OVERRIDE'] = 1)] = 'OVERRIDE'; + SectionOverrideMode2[(SectionOverrideMode2['APPEND'] = 2)] = 'APPEND'; + SectionOverrideMode2[(SectionOverrideMode2['PREPEND'] = 3)] = 'PREPEND'; +})(SectionOverrideMode || (SectionOverrideMode = {})); +proto3.util.setEnumType( + SectionOverrideMode, + 'exa.cortex_pb.SectionOverrideMode', + [ + { no: 0, name: 'SECTION_OVERRIDE_MODE_UNSPECIFIED' }, + { no: 1, name: 'SECTION_OVERRIDE_MODE_OVERRIDE' }, + { no: 2, name: 'SECTION_OVERRIDE_MODE_APPEND' }, + { no: 3, name: 'SECTION_OVERRIDE_MODE_PREPEND' }, + ], +); +var AgentMode; +(function (AgentMode2) { + AgentMode2[(AgentMode2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + AgentMode2[(AgentMode2['PLANNING'] = 1)] = 'PLANNING'; + AgentMode2[(AgentMode2['EXECUTION'] = 2)] = 'EXECUTION'; + AgentMode2[(AgentMode2['VERIFICATION'] = 3)] = 'VERIFICATION'; +})(AgentMode || (AgentMode = {})); +proto3.util.setEnumType(AgentMode, 'exa.cortex_pb.AgentMode', [ + { no: 0, name: 'AGENT_MODE_UNSPECIFIED' }, + { no: 1, name: 'AGENT_MODE_PLANNING' }, + { no: 2, name: 'AGENT_MODE_EXECUTION' }, + { no: 3, name: 'AGENT_MODE_VERIFICATION' }, +]); +var ReplaceToolVariant; +(function (ReplaceToolVariant2) { + ReplaceToolVariant2[(ReplaceToolVariant2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ReplaceToolVariant2[(ReplaceToolVariant2['REPLACEMENT_CHUNK'] = 1)] = + 'REPLACEMENT_CHUNK'; + ReplaceToolVariant2[(ReplaceToolVariant2['SEARCH_REPLACE'] = 2)] = + 'SEARCH_REPLACE'; + ReplaceToolVariant2[(ReplaceToolVariant2['APPLY_PATCH'] = 3)] = 'APPLY_PATCH'; + ReplaceToolVariant2[(ReplaceToolVariant2['SINGLE_MULTI'] = 4)] = + 'SINGLE_MULTI'; +})(ReplaceToolVariant || (ReplaceToolVariant = {})); +proto3.util.setEnumType( + ReplaceToolVariant, + 'exa.cortex_pb.ReplaceToolVariant', + [ + { no: 0, name: 'REPLACE_TOOL_VARIANT_UNSPECIFIED' }, + { no: 1, name: 'REPLACE_TOOL_VARIANT_REPLACEMENT_CHUNK' }, + { no: 2, name: 'REPLACE_TOOL_VARIANT_SEARCH_REPLACE' }, + { no: 3, name: 'REPLACE_TOOL_VARIANT_APPLY_PATCH' }, + { no: 4, name: 'REPLACE_TOOL_VARIANT_SINGLE_MULTI' }, + ], +); +var BrowserSubagentMode; +(function (BrowserSubagentMode2) { + BrowserSubagentMode2[(BrowserSubagentMode2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + BrowserSubagentMode2[(BrowserSubagentMode2['MAIN_AGENT_ONLY'] = 1)] = + 'MAIN_AGENT_ONLY'; + BrowserSubagentMode2[(BrowserSubagentMode2['SUBAGENT_PRIMARILY'] = 2)] = + 'SUBAGENT_PRIMARILY'; + BrowserSubagentMode2[(BrowserSubagentMode2['BOTH_AGENTS'] = 3)] = + 'BOTH_AGENTS'; + BrowserSubagentMode2[(BrowserSubagentMode2['SUBAGENT_ONLY'] = 4)] = + 'SUBAGENT_ONLY'; +})(BrowserSubagentMode || (BrowserSubagentMode = {})); +proto3.util.setEnumType( + BrowserSubagentMode, + 'exa.cortex_pb.BrowserSubagentMode', + [ + { no: 0, name: 'BROWSER_SUBAGENT_MODE_UNSPECIFIED' }, + { no: 1, name: 'BROWSER_SUBAGENT_MODE_MAIN_AGENT_ONLY' }, + { no: 2, name: 'BROWSER_SUBAGENT_MODE_SUBAGENT_PRIMARILY' }, + { no: 3, name: 'BROWSER_SUBAGENT_MODE_BOTH_AGENTS' }, + { no: 4, name: 'BROWSER_SUBAGENT_MODE_SUBAGENT_ONLY' }, + ], +); +var BrowserToolSetMode; +(function (BrowserToolSetMode2) { + BrowserToolSetMode2[(BrowserToolSetMode2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + BrowserToolSetMode2[(BrowserToolSetMode2['ALL_TOOLS'] = 1)] = 'ALL_TOOLS'; + BrowserToolSetMode2[(BrowserToolSetMode2['PIXEL_ONLY'] = 2)] = 'PIXEL_ONLY'; + BrowserToolSetMode2[(BrowserToolSetMode2['ALL_INPUT_PIXEL_OUTPUT'] = 3)] = + 'ALL_INPUT_PIXEL_OUTPUT'; +})(BrowserToolSetMode || (BrowserToolSetMode = {})); +proto3.util.setEnumType( + BrowserToolSetMode, + 'exa.cortex_pb.BrowserToolSetMode', + [ + { no: 0, name: 'BROWSER_TOOL_SET_MODE_UNSPECIFIED' }, + { no: 1, name: 'BROWSER_TOOL_SET_MODE_ALL_TOOLS' }, + { no: 2, name: 'BROWSER_TOOL_SET_MODE_PIXEL_ONLY' }, + { no: 3, name: 'BROWSER_TOOL_SET_MODE_ALL_INPUT_PIXEL_OUTPUT' }, + ], +); +var BrowserActionWaitingReason; +(function (BrowserActionWaitingReason2) { + BrowserActionWaitingReason2[ + (BrowserActionWaitingReason2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + BrowserActionWaitingReason2[ + (BrowserActionWaitingReason2['PAGE_ACCESS'] = 1) + ] = 'PAGE_ACCESS'; + BrowserActionWaitingReason2[ + (BrowserActionWaitingReason2['ACTION_PERMISSION'] = 2) + ] = 'ACTION_PERMISSION'; + BrowserActionWaitingReason2[ + (BrowserActionWaitingReason2['PAGE_ACCESS_AND_ACTION_PERMISSION'] = 3) + ] = 'PAGE_ACCESS_AND_ACTION_PERMISSION'; +})(BrowserActionWaitingReason || (BrowserActionWaitingReason = {})); +proto3.util.setEnumType( + BrowserActionWaitingReason, + 'exa.cortex_pb.BrowserActionWaitingReason', + [ + { no: 0, name: 'BROWSER_ACTION_WAITING_REASON_UNSPECIFIED' }, + { no: 1, name: 'BROWSER_ACTION_WAITING_REASON_PAGE_ACCESS' }, + { no: 2, name: 'BROWSER_ACTION_WAITING_REASON_ACTION_PERMISSION' }, + { + no: 3, + name: 'BROWSER_ACTION_WAITING_REASON_PAGE_ACCESS_AND_ACTION_PERMISSION', + }, + ], +); +var PermissionScope; +(function (PermissionScope2) { + PermissionScope2[(PermissionScope2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + PermissionScope2[(PermissionScope2['ONCE'] = 1)] = 'ONCE'; + PermissionScope2[(PermissionScope2['CONVERSATION'] = 2)] = 'CONVERSATION'; +})(PermissionScope || (PermissionScope = {})); +proto3.util.setEnumType(PermissionScope, 'exa.cortex_pb.PermissionScope', [ + { no: 0, name: 'PERMISSION_SCOPE_UNSPECIFIED' }, + { no: 1, name: 'PERMISSION_SCOPE_ONCE' }, + { no: 2, name: 'PERMISSION_SCOPE_CONVERSATION' }, +]); +var CortexStepType; +(function (CortexStepType2) { + CortexStepType2[(CortexStepType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CortexStepType2[(CortexStepType2['DUMMY'] = 1)] = 'DUMMY'; + CortexStepType2[(CortexStepType2['FINISH'] = 2)] = 'FINISH'; + CortexStepType2[(CortexStepType2['MQUERY'] = 4)] = 'MQUERY'; + CortexStepType2[(CortexStepType2['CODE_ACTION'] = 5)] = 'CODE_ACTION'; + CortexStepType2[(CortexStepType2['GIT_COMMIT'] = 6)] = 'GIT_COMMIT'; + CortexStepType2[(CortexStepType2['GREP_SEARCH'] = 7)] = 'GREP_SEARCH'; + CortexStepType2[(CortexStepType2['COMPILE'] = 10)] = 'COMPILE'; + CortexStepType2[(CortexStepType2['VIEW_CODE_ITEM'] = 13)] = 'VIEW_CODE_ITEM'; + CortexStepType2[(CortexStepType2['ERROR_MESSAGE'] = 17)] = 'ERROR_MESSAGE'; + CortexStepType2[(CortexStepType2['RUN_COMMAND'] = 21)] = 'RUN_COMMAND'; + CortexStepType2[(CortexStepType2['FIND'] = 25)] = 'FIND'; + CortexStepType2[(CortexStepType2['SUGGESTED_RESPONSES'] = 27)] = + 'SUGGESTED_RESPONSES'; + CortexStepType2[(CortexStepType2['COMMAND_STATUS'] = 28)] = 'COMMAND_STATUS'; + CortexStepType2[(CortexStepType2['READ_URL_CONTENT'] = 31)] = + 'READ_URL_CONTENT'; + CortexStepType2[(CortexStepType2['VIEW_CONTENT_CHUNK'] = 32)] = + 'VIEW_CONTENT_CHUNK'; + CortexStepType2[(CortexStepType2['SEARCH_WEB'] = 33)] = 'SEARCH_WEB'; + CortexStepType2[(CortexStepType2['MCP_TOOL'] = 38)] = 'MCP_TOOL'; + CortexStepType2[(CortexStepType2['CLIPBOARD'] = 45)] = 'CLIPBOARD'; + CortexStepType2[(CortexStepType2['VIEW_FILE_OUTLINE'] = 47)] = + 'VIEW_FILE_OUTLINE'; + CortexStepType2[(CortexStepType2['LIST_RESOURCES'] = 51)] = 'LIST_RESOURCES'; + CortexStepType2[(CortexStepType2['READ_RESOURCE'] = 52)] = 'READ_RESOURCE'; + CortexStepType2[(CortexStepType2['LINT_DIFF'] = 53)] = 'LINT_DIFF'; + CortexStepType2[(CortexStepType2['OPEN_BROWSER_URL'] = 56)] = + 'OPEN_BROWSER_URL'; + CortexStepType2[(CortexStepType2['RUN_EXTENSION_CODE'] = 57)] = + 'RUN_EXTENSION_CODE'; + CortexStepType2[(CortexStepType2['TRAJECTORY_SEARCH'] = 60)] = + 'TRAJECTORY_SEARCH'; + CortexStepType2[(CortexStepType2['EXECUTE_BROWSER_JAVASCRIPT'] = 61)] = + 'EXECUTE_BROWSER_JAVASCRIPT'; + CortexStepType2[(CortexStepType2['LIST_BROWSER_PAGES'] = 62)] = + 'LIST_BROWSER_PAGES'; + CortexStepType2[(CortexStepType2['CAPTURE_BROWSER_SCREENSHOT'] = 63)] = + 'CAPTURE_BROWSER_SCREENSHOT'; + CortexStepType2[(CortexStepType2['CLICK_BROWSER_PIXEL'] = 64)] = + 'CLICK_BROWSER_PIXEL'; + CortexStepType2[(CortexStepType2['READ_TERMINAL'] = 65)] = 'READ_TERMINAL'; + CortexStepType2[(CortexStepType2['CAPTURE_BROWSER_CONSOLE_LOGS'] = 66)] = + 'CAPTURE_BROWSER_CONSOLE_LOGS'; + CortexStepType2[(CortexStepType2['READ_BROWSER_PAGE'] = 67)] = + 'READ_BROWSER_PAGE'; + CortexStepType2[(CortexStepType2['BROWSER_GET_DOM'] = 68)] = + 'BROWSER_GET_DOM'; + CortexStepType2[(CortexStepType2['CODE_SEARCH'] = 73)] = 'CODE_SEARCH'; + CortexStepType2[(CortexStepType2['BROWSER_INPUT'] = 74)] = 'BROWSER_INPUT'; + CortexStepType2[(CortexStepType2['BROWSER_MOVE_MOUSE'] = 75)] = + 'BROWSER_MOVE_MOUSE'; + CortexStepType2[(CortexStepType2['BROWSER_SELECT_OPTION'] = 76)] = + 'BROWSER_SELECT_OPTION'; + CortexStepType2[(CortexStepType2['BROWSER_SCROLL_UP'] = 77)] = + 'BROWSER_SCROLL_UP'; + CortexStepType2[(CortexStepType2['BROWSER_SCROLL_DOWN'] = 78)] = + 'BROWSER_SCROLL_DOWN'; + CortexStepType2[(CortexStepType2['BROWSER_CLICK_ELEMENT'] = 79)] = + 'BROWSER_CLICK_ELEMENT'; + CortexStepType2[(CortexStepType2['BROWSER_LIST_NETWORK_REQUESTS'] = 123)] = + 'BROWSER_LIST_NETWORK_REQUESTS'; + CortexStepType2[(CortexStepType2['BROWSER_GET_NETWORK_REQUEST'] = 124)] = + 'BROWSER_GET_NETWORK_REQUEST'; + CortexStepType2[(CortexStepType2['BROWSER_PRESS_KEY'] = 80)] = + 'BROWSER_PRESS_KEY'; + CortexStepType2[(CortexStepType2['TASK_BOUNDARY'] = 81)] = 'TASK_BOUNDARY'; + CortexStepType2[(CortexStepType2['NOTIFY_USER'] = 82)] = 'NOTIFY_USER'; + CortexStepType2[(CortexStepType2['CODE_ACKNOWLEDGEMENT'] = 83)] = + 'CODE_ACKNOWLEDGEMENT'; + CortexStepType2[(CortexStepType2['INTERNAL_SEARCH'] = 84)] = + 'INTERNAL_SEARCH'; + CortexStepType2[(CortexStepType2['BROWSER_SUBAGENT'] = 85)] = + 'BROWSER_SUBAGENT'; + CortexStepType2[(CortexStepType2['BROWSER_SCROLL'] = 88)] = 'BROWSER_SCROLL'; + CortexStepType2[(CortexStepType2['KNOWLEDGE_GENERATION'] = 89)] = + 'KNOWLEDGE_GENERATION'; + CortexStepType2[(CortexStepType2['GENERATE_IMAGE'] = 91)] = 'GENERATE_IMAGE'; + CortexStepType2[(CortexStepType2['BROWSER_RESIZE_WINDOW'] = 96)] = + 'BROWSER_RESIZE_WINDOW'; + CortexStepType2[(CortexStepType2['BROWSER_DRAG_PIXEL_TO_PIXEL'] = 97)] = + 'BROWSER_DRAG_PIXEL_TO_PIXEL'; + CortexStepType2[(CortexStepType2['BROWSER_MOUSE_WHEEL'] = 113)] = + 'BROWSER_MOUSE_WHEEL'; + CortexStepType2[(CortexStepType2['BROWSER_MOUSE_UP'] = 120)] = + 'BROWSER_MOUSE_UP'; + CortexStepType2[(CortexStepType2['BROWSER_MOUSE_DOWN'] = 121)] = + 'BROWSER_MOUSE_DOWN'; + CortexStepType2[(CortexStepType2['BROWSER_REFRESH_PAGE'] = 125)] = + 'BROWSER_REFRESH_PAGE'; + CortexStepType2[(CortexStepType2['CONVERSATION_HISTORY'] = 98)] = + 'CONVERSATION_HISTORY'; + CortexStepType2[(CortexStepType2['KNOWLEDGE_ARTIFACTS'] = 99)] = + 'KNOWLEDGE_ARTIFACTS'; + CortexStepType2[(CortexStepType2['SEND_COMMAND_INPUT'] = 100)] = + 'SEND_COMMAND_INPUT'; + CortexStepType2[(CortexStepType2['SYSTEM_MESSAGE'] = 101)] = 'SYSTEM_MESSAGE'; + CortexStepType2[(CortexStepType2['WAIT'] = 102)] = 'WAIT'; + CortexStepType2[(CortexStepType2['KI_INSERTION'] = 116)] = 'KI_INSERTION'; + CortexStepType2[(CortexStepType2['WORKSPACE_API'] = 122)] = 'WORKSPACE_API'; + CortexStepType2[(CortexStepType2['INVOKE_SUBAGENT'] = 127)] = + 'INVOKE_SUBAGENT'; + CortexStepType2[(CortexStepType2['USER_INPUT'] = 14)] = 'USER_INPUT'; + CortexStepType2[(CortexStepType2['PLANNER_RESPONSE'] = 15)] = + 'PLANNER_RESPONSE'; + CortexStepType2[(CortexStepType2['VIEW_FILE'] = 8)] = 'VIEW_FILE'; + CortexStepType2[(CortexStepType2['LIST_DIRECTORY'] = 9)] = 'LIST_DIRECTORY'; + CortexStepType2[(CortexStepType2['CHECKPOINT'] = 23)] = 'CHECKPOINT'; + CortexStepType2[(CortexStepType2['FILE_CHANGE'] = 86)] = 'FILE_CHANGE'; + CortexStepType2[(CortexStepType2['DELETE_DIRECTORY'] = 92)] = + 'DELETE_DIRECTORY'; + CortexStepType2[(CortexStepType2['MOVE'] = 87)] = 'MOVE'; + CortexStepType2[(CortexStepType2['EPHEMERAL_MESSAGE'] = 90)] = + 'EPHEMERAL_MESSAGE'; + CortexStepType2[(CortexStepType2['COMPILE_APPLET'] = 93)] = 'COMPILE_APPLET'; + CortexStepType2[(CortexStepType2['INSTALL_APPLET_DEPENDENCIES'] = 94)] = + 'INSTALL_APPLET_DEPENDENCIES'; + CortexStepType2[(CortexStepType2['INSTALL_APPLET_PACKAGE'] = 95)] = + 'INSTALL_APPLET_PACKAGE'; + CortexStepType2[(CortexStepType2['SET_UP_FIREBASE'] = 108)] = + 'SET_UP_FIREBASE'; + CortexStepType2[(CortexStepType2['RESTART_DEV_SERVER'] = 110)] = + 'RESTART_DEV_SERVER'; + CortexStepType2[(CortexStepType2['DEPLOY_FIREBASE'] = 111)] = + 'DEPLOY_FIREBASE'; + CortexStepType2[(CortexStepType2['SHELL_EXEC'] = 112)] = 'SHELL_EXEC'; + CortexStepType2[(CortexStepType2['LINT_APPLET'] = 114)] = 'LINT_APPLET'; + CortexStepType2[(CortexStepType2['DEFINE_NEW_ENV_VARIABLE'] = 115)] = + 'DEFINE_NEW_ENV_VARIABLE'; + CortexStepType2[(CortexStepType2['WRITE_BLOB'] = 128)] = 'WRITE_BLOB'; + CortexStepType2[(CortexStepType2['AGENCY_TOOL_CALL'] = 103)] = + 'AGENCY_TOOL_CALL'; + CortexStepType2[(CortexStepType2['PLAN_INPUT'] = 3)] = 'PLAN_INPUT'; + CortexStepType2[(CortexStepType2['PROPOSE_CODE'] = 24)] = 'PROPOSE_CODE'; + CortexStepType2[(CortexStepType2['MANAGER_FEEDBACK'] = 39)] = + 'MANAGER_FEEDBACK'; + CortexStepType2[(CortexStepType2['TOOL_CALL_PROPOSAL'] = 40)] = + 'TOOL_CALL_PROPOSAL'; + CortexStepType2[(CortexStepType2['TOOL_CALL_CHOICE'] = 41)] = + 'TOOL_CALL_CHOICE'; + CortexStepType2[(CortexStepType2['TRAJECTORY_CHOICE'] = 42)] = + 'TRAJECTORY_CHOICE'; + CortexStepType2[(CortexStepType2['POST_PR_REVIEW'] = 49)] = 'POST_PR_REVIEW'; + CortexStepType2[(CortexStepType2['FIND_ALL_REFERENCES'] = 54)] = + 'FIND_ALL_REFERENCES'; + CortexStepType2[(CortexStepType2['BRAIN_UPDATE'] = 55)] = 'BRAIN_UPDATE'; + CortexStepType2[(CortexStepType2['ADD_ANNOTATION'] = 58)] = 'ADD_ANNOTATION'; + CortexStepType2[(CortexStepType2['PROPOSAL_FEEDBACK'] = 59)] = + 'PROPOSAL_FEEDBACK'; + CortexStepType2[(CortexStepType2['RETRIEVE_MEMORY'] = 34)] = + 'RETRIEVE_MEMORY'; + CortexStepType2[(CortexStepType2['MEMORY'] = 29)] = 'MEMORY'; +})(CortexStepType || (CortexStepType = {})); +proto3.util.setEnumType(CortexStepType, 'exa.cortex_pb.CortexStepType', [ + { no: 0, name: 'CORTEX_STEP_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_STEP_TYPE_DUMMY' }, + { no: 2, name: 'CORTEX_STEP_TYPE_FINISH' }, + { no: 4, name: 'CORTEX_STEP_TYPE_MQUERY' }, + { no: 5, name: 'CORTEX_STEP_TYPE_CODE_ACTION' }, + { no: 6, name: 'CORTEX_STEP_TYPE_GIT_COMMIT' }, + { no: 7, name: 'CORTEX_STEP_TYPE_GREP_SEARCH' }, + { no: 10, name: 'CORTEX_STEP_TYPE_COMPILE' }, + { no: 13, name: 'CORTEX_STEP_TYPE_VIEW_CODE_ITEM' }, + { no: 17, name: 'CORTEX_STEP_TYPE_ERROR_MESSAGE' }, + { no: 21, name: 'CORTEX_STEP_TYPE_RUN_COMMAND' }, + { no: 25, name: 'CORTEX_STEP_TYPE_FIND' }, + { no: 27, name: 'CORTEX_STEP_TYPE_SUGGESTED_RESPONSES' }, + { no: 28, name: 'CORTEX_STEP_TYPE_COMMAND_STATUS' }, + { no: 31, name: 'CORTEX_STEP_TYPE_READ_URL_CONTENT' }, + { no: 32, name: 'CORTEX_STEP_TYPE_VIEW_CONTENT_CHUNK' }, + { no: 33, name: 'CORTEX_STEP_TYPE_SEARCH_WEB' }, + { no: 38, name: 'CORTEX_STEP_TYPE_MCP_TOOL' }, + { no: 45, name: 'CORTEX_STEP_TYPE_CLIPBOARD' }, + { no: 47, name: 'CORTEX_STEP_TYPE_VIEW_FILE_OUTLINE' }, + { no: 51, name: 'CORTEX_STEP_TYPE_LIST_RESOURCES' }, + { no: 52, name: 'CORTEX_STEP_TYPE_READ_RESOURCE' }, + { no: 53, name: 'CORTEX_STEP_TYPE_LINT_DIFF' }, + { no: 56, name: 'CORTEX_STEP_TYPE_OPEN_BROWSER_URL' }, + { no: 57, name: 'CORTEX_STEP_TYPE_RUN_EXTENSION_CODE' }, + { no: 60, name: 'CORTEX_STEP_TYPE_TRAJECTORY_SEARCH' }, + { no: 61, name: 'CORTEX_STEP_TYPE_EXECUTE_BROWSER_JAVASCRIPT' }, + { no: 62, name: 'CORTEX_STEP_TYPE_LIST_BROWSER_PAGES' }, + { no: 63, name: 'CORTEX_STEP_TYPE_CAPTURE_BROWSER_SCREENSHOT' }, + { no: 64, name: 'CORTEX_STEP_TYPE_CLICK_BROWSER_PIXEL' }, + { no: 65, name: 'CORTEX_STEP_TYPE_READ_TERMINAL' }, + { no: 66, name: 'CORTEX_STEP_TYPE_CAPTURE_BROWSER_CONSOLE_LOGS' }, + { no: 67, name: 'CORTEX_STEP_TYPE_READ_BROWSER_PAGE' }, + { no: 68, name: 'CORTEX_STEP_TYPE_BROWSER_GET_DOM' }, + { no: 73, name: 'CORTEX_STEP_TYPE_CODE_SEARCH' }, + { no: 74, name: 'CORTEX_STEP_TYPE_BROWSER_INPUT' }, + { no: 75, name: 'CORTEX_STEP_TYPE_BROWSER_MOVE_MOUSE' }, + { no: 76, name: 'CORTEX_STEP_TYPE_BROWSER_SELECT_OPTION' }, + { no: 77, name: 'CORTEX_STEP_TYPE_BROWSER_SCROLL_UP' }, + { no: 78, name: 'CORTEX_STEP_TYPE_BROWSER_SCROLL_DOWN' }, + { no: 79, name: 'CORTEX_STEP_TYPE_BROWSER_CLICK_ELEMENT' }, + { no: 123, name: 'CORTEX_STEP_TYPE_BROWSER_LIST_NETWORK_REQUESTS' }, + { no: 124, name: 'CORTEX_STEP_TYPE_BROWSER_GET_NETWORK_REQUEST' }, + { no: 80, name: 'CORTEX_STEP_TYPE_BROWSER_PRESS_KEY' }, + { no: 81, name: 'CORTEX_STEP_TYPE_TASK_BOUNDARY' }, + { no: 82, name: 'CORTEX_STEP_TYPE_NOTIFY_USER' }, + { no: 83, name: 'CORTEX_STEP_TYPE_CODE_ACKNOWLEDGEMENT' }, + { no: 84, name: 'CORTEX_STEP_TYPE_INTERNAL_SEARCH' }, + { no: 85, name: 'CORTEX_STEP_TYPE_BROWSER_SUBAGENT' }, + { no: 88, name: 'CORTEX_STEP_TYPE_BROWSER_SCROLL' }, + { no: 89, name: 'CORTEX_STEP_TYPE_KNOWLEDGE_GENERATION' }, + { no: 91, name: 'CORTEX_STEP_TYPE_GENERATE_IMAGE' }, + { no: 96, name: 'CORTEX_STEP_TYPE_BROWSER_RESIZE_WINDOW' }, + { no: 97, name: 'CORTEX_STEP_TYPE_BROWSER_DRAG_PIXEL_TO_PIXEL' }, + { no: 113, name: 'CORTEX_STEP_TYPE_BROWSER_MOUSE_WHEEL' }, + { no: 120, name: 'CORTEX_STEP_TYPE_BROWSER_MOUSE_UP' }, + { no: 121, name: 'CORTEX_STEP_TYPE_BROWSER_MOUSE_DOWN' }, + { no: 125, name: 'CORTEX_STEP_TYPE_BROWSER_REFRESH_PAGE' }, + { no: 98, name: 'CORTEX_STEP_TYPE_CONVERSATION_HISTORY' }, + { no: 99, name: 'CORTEX_STEP_TYPE_KNOWLEDGE_ARTIFACTS' }, + { no: 100, name: 'CORTEX_STEP_TYPE_SEND_COMMAND_INPUT' }, + { no: 101, name: 'CORTEX_STEP_TYPE_SYSTEM_MESSAGE' }, + { no: 102, name: 'CORTEX_STEP_TYPE_WAIT' }, + { no: 116, name: 'CORTEX_STEP_TYPE_KI_INSERTION' }, + { no: 122, name: 'CORTEX_STEP_TYPE_WORKSPACE_API' }, + { no: 127, name: 'CORTEX_STEP_TYPE_INVOKE_SUBAGENT' }, + { no: 14, name: 'CORTEX_STEP_TYPE_USER_INPUT' }, + { no: 15, name: 'CORTEX_STEP_TYPE_PLANNER_RESPONSE' }, + { no: 8, name: 'CORTEX_STEP_TYPE_VIEW_FILE' }, + { no: 9, name: 'CORTEX_STEP_TYPE_LIST_DIRECTORY' }, + { no: 23, name: 'CORTEX_STEP_TYPE_CHECKPOINT' }, + { no: 86, name: 'CORTEX_STEP_TYPE_FILE_CHANGE' }, + { no: 92, name: 'CORTEX_STEP_TYPE_DELETE_DIRECTORY' }, + { no: 87, name: 'CORTEX_STEP_TYPE_MOVE' }, + { no: 90, name: 'CORTEX_STEP_TYPE_EPHEMERAL_MESSAGE' }, + { no: 93, name: 'CORTEX_STEP_TYPE_COMPILE_APPLET' }, + { no: 94, name: 'CORTEX_STEP_TYPE_INSTALL_APPLET_DEPENDENCIES' }, + { no: 95, name: 'CORTEX_STEP_TYPE_INSTALL_APPLET_PACKAGE' }, + { no: 108, name: 'CORTEX_STEP_TYPE_SET_UP_FIREBASE' }, + { no: 110, name: 'CORTEX_STEP_TYPE_RESTART_DEV_SERVER' }, + { no: 111, name: 'CORTEX_STEP_TYPE_DEPLOY_FIREBASE' }, + { no: 112, name: 'CORTEX_STEP_TYPE_SHELL_EXEC' }, + { no: 114, name: 'CORTEX_STEP_TYPE_LINT_APPLET' }, + { no: 115, name: 'CORTEX_STEP_TYPE_DEFINE_NEW_ENV_VARIABLE' }, + { no: 128, name: 'CORTEX_STEP_TYPE_WRITE_BLOB' }, + { no: 103, name: 'CORTEX_STEP_TYPE_AGENCY_TOOL_CALL' }, + { no: 3, name: 'CORTEX_STEP_TYPE_PLAN_INPUT' }, + { no: 24, name: 'CORTEX_STEP_TYPE_PROPOSE_CODE' }, + { no: 39, name: 'CORTEX_STEP_TYPE_MANAGER_FEEDBACK' }, + { no: 40, name: 'CORTEX_STEP_TYPE_TOOL_CALL_PROPOSAL' }, + { no: 41, name: 'CORTEX_STEP_TYPE_TOOL_CALL_CHOICE' }, + { no: 42, name: 'CORTEX_STEP_TYPE_TRAJECTORY_CHOICE' }, + { no: 49, name: 'CORTEX_STEP_TYPE_POST_PR_REVIEW' }, + { no: 54, name: 'CORTEX_STEP_TYPE_FIND_ALL_REFERENCES' }, + { no: 55, name: 'CORTEX_STEP_TYPE_BRAIN_UPDATE' }, + { no: 58, name: 'CORTEX_STEP_TYPE_ADD_ANNOTATION' }, + { no: 59, name: 'CORTEX_STEP_TYPE_PROPOSAL_FEEDBACK' }, + { no: 34, name: 'CORTEX_STEP_TYPE_RETRIEVE_MEMORY' }, + { no: 29, name: 'CORTEX_STEP_TYPE_MEMORY' }, +]); +var CheckpointType; +(function (CheckpointType2) { + CheckpointType2[(CheckpointType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; +})(CheckpointType || (CheckpointType = {})); +proto3.util.setEnumType(CheckpointType, 'exa.cortex_pb.CheckpointType', [ + { no: 0, name: 'CHECKPOINT_TYPE_UNSPECIFIED' }, +]); +var SemanticCodebaseSearchType; +(function (SemanticCodebaseSearchType2) { + SemanticCodebaseSearchType2[ + (SemanticCodebaseSearchType2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + SemanticCodebaseSearchType2[(SemanticCodebaseSearchType2['MQUERY'] = 1)] = + 'MQUERY'; + SemanticCodebaseSearchType2[ + (SemanticCodebaseSearchType2['VECTOR_INDEX'] = 2) + ] = 'VECTOR_INDEX'; +})(SemanticCodebaseSearchType || (SemanticCodebaseSearchType = {})); +proto3.util.setEnumType( + SemanticCodebaseSearchType, + 'exa.cortex_pb.SemanticCodebaseSearchType', + [ + { no: 0, name: 'SEMANTIC_CODEBASE_SEARCH_TYPE_UNSPECIFIED' }, + { no: 1, name: 'SEMANTIC_CODEBASE_SEARCH_TYPE_MQUERY' }, + { no: 2, name: 'SEMANTIC_CODEBASE_SEARCH_TYPE_VECTOR_INDEX' }, + ], +); +var AcknowledgementType; +(function (AcknowledgementType2) { + AcknowledgementType2[(AcknowledgementType2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + AcknowledgementType2[(AcknowledgementType2['ACCEPT'] = 1)] = 'ACCEPT'; + AcknowledgementType2[(AcknowledgementType2['REJECT'] = 2)] = 'REJECT'; + AcknowledgementType2[(AcknowledgementType2['STALE'] = 3)] = 'STALE'; + AcknowledgementType2[(AcknowledgementType2['CLEARED'] = 4)] = 'CLEARED'; +})(AcknowledgementType || (AcknowledgementType = {})); +proto3.util.setEnumType( + AcknowledgementType, + 'exa.cortex_pb.AcknowledgementType', + [ + { no: 0, name: 'ACKNOWLEDGEMENT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'ACKNOWLEDGEMENT_TYPE_ACCEPT' }, + { no: 2, name: 'ACKNOWLEDGEMENT_TYPE_REJECT' }, + { no: 3, name: 'ACKNOWLEDGEMENT_TYPE_STALE' }, + { no: 4, name: 'ACKNOWLEDGEMENT_TYPE_CLEARED' }, + ], +); +var CodeHeuristicFailure; +(function (CodeHeuristicFailure2) { + CodeHeuristicFailure2[(CodeHeuristicFailure2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CodeHeuristicFailure2[(CodeHeuristicFailure2['LAZY_COMMENT'] = 1)] = + 'LAZY_COMMENT'; + CodeHeuristicFailure2[(CodeHeuristicFailure2['DELETED_LINES'] = 2)] = + 'DELETED_LINES'; +})(CodeHeuristicFailure || (CodeHeuristicFailure = {})); +proto3.util.setEnumType( + CodeHeuristicFailure, + 'exa.cortex_pb.CodeHeuristicFailure', + [ + { no: 0, name: 'CODE_HEURISTIC_FAILURE_UNSPECIFIED' }, + { no: 1, name: 'CODE_HEURISTIC_FAILURE_LAZY_COMMENT' }, + { no: 2, name: 'CODE_HEURISTIC_FAILURE_DELETED_LINES' }, + ], +); +var FileChangeType; +(function (FileChangeType2) { + FileChangeType2[(FileChangeType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + FileChangeType2[(FileChangeType2['CREATE'] = 1)] = 'CREATE'; + FileChangeType2[(FileChangeType2['EDIT'] = 2)] = 'EDIT'; + FileChangeType2[(FileChangeType2['DELETE'] = 3)] = 'DELETE'; +})(FileChangeType || (FileChangeType = {})); +proto3.util.setEnumType(FileChangeType, 'exa.cortex_pb.FileChangeType', [ + { no: 0, name: 'FILE_CHANGE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'FILE_CHANGE_TYPE_CREATE' }, + { no: 2, name: 'FILE_CHANGE_TYPE_EDIT' }, + { no: 3, name: 'FILE_CHANGE_TYPE_DELETE' }, +]); +var FindResultType; +(function (FindResultType2) { + FindResultType2[(FindResultType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + FindResultType2[(FindResultType2['FILE'] = 1)] = 'FILE'; + FindResultType2[(FindResultType2['DIRECTORY'] = 2)] = 'DIRECTORY'; + FindResultType2[(FindResultType2['ANY'] = 3)] = 'ANY'; +})(FindResultType || (FindResultType = {})); +proto3.util.setEnumType(FindResultType, 'exa.cortex_pb.FindResultType', [ + { no: 0, name: 'FIND_RESULT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'FIND_RESULT_TYPE_FILE' }, + { no: 2, name: 'FIND_RESULT_TYPE_DIRECTORY' }, + { no: 3, name: 'FIND_RESULT_TYPE_ANY' }, +]); +var CortexStepCompileTool; +(function (CortexStepCompileTool2) { + CortexStepCompileTool2[(CortexStepCompileTool2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CortexStepCompileTool2[(CortexStepCompileTool2['PYLINT'] = 1)] = 'PYLINT'; +})(CortexStepCompileTool || (CortexStepCompileTool = {})); +proto3.util.setEnumType( + CortexStepCompileTool, + 'exa.cortex_pb.CortexStepCompileTool', + [ + { no: 0, name: 'CORTEX_STEP_COMPILE_TOOL_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_STEP_COMPILE_TOOL_PYLINT' }, + ], +); +var SetUpFirebaseErrorCode; +(function (SetUpFirebaseErrorCode2) { + SetUpFirebaseErrorCode2[(SetUpFirebaseErrorCode2['ERROR_CODE_OK'] = 0)] = + 'ERROR_CODE_OK'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_CANCELLED'] = 1) + ] = 'ERROR_CODE_CANCELLED'; + SetUpFirebaseErrorCode2[(SetUpFirebaseErrorCode2['ERROR_CODE_UNKNOWN'] = 2)] = + 'ERROR_CODE_UNKNOWN'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_INVALID_ARGUMENT'] = 3) + ] = 'ERROR_CODE_INVALID_ARGUMENT'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_DEADLINE_EXCEEDED'] = 4) + ] = 'ERROR_CODE_DEADLINE_EXCEEDED'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_NOT_FOUND'] = 5) + ] = 'ERROR_CODE_NOT_FOUND'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_ALREADY_EXISTS'] = 6) + ] = 'ERROR_CODE_ALREADY_EXISTS'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_PERMISSION_DENIED'] = 7) + ] = 'ERROR_CODE_PERMISSION_DENIED'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_UNAUTHENTICATED'] = 16) + ] = 'ERROR_CODE_UNAUTHENTICATED'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_RESOURCE_EXHAUSTED'] = 8) + ] = 'ERROR_CODE_RESOURCE_EXHAUSTED'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_FAILED_PRECONDITION'] = 9) + ] = 'ERROR_CODE_FAILED_PRECONDITION'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_ABORTED'] = 10) + ] = 'ERROR_CODE_ABORTED'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_OUT_OF_RANGE'] = 11) + ] = 'ERROR_CODE_OUT_OF_RANGE'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_UNIMPLEMENTED'] = 12) + ] = 'ERROR_CODE_UNIMPLEMENTED'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_INTERNAL'] = 13) + ] = 'ERROR_CODE_INTERNAL'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_UNAVAILABLE'] = 14) + ] = 'ERROR_CODE_UNAVAILABLE'; + SetUpFirebaseErrorCode2[ + (SetUpFirebaseErrorCode2['ERROR_CODE_DATA_LOSS'] = 15) + ] = 'ERROR_CODE_DATA_LOSS'; +})(SetUpFirebaseErrorCode || (SetUpFirebaseErrorCode = {})); +proto3.util.setEnumType( + SetUpFirebaseErrorCode, + 'exa.cortex_pb.SetUpFirebaseErrorCode', + [ + { no: 0, name: 'ERROR_CODE_OK' }, + { no: 1, name: 'ERROR_CODE_CANCELLED' }, + { no: 2, name: 'ERROR_CODE_UNKNOWN' }, + { no: 3, name: 'ERROR_CODE_INVALID_ARGUMENT' }, + { no: 4, name: 'ERROR_CODE_DEADLINE_EXCEEDED' }, + { no: 5, name: 'ERROR_CODE_NOT_FOUND' }, + { no: 6, name: 'ERROR_CODE_ALREADY_EXISTS' }, + { no: 7, name: 'ERROR_CODE_PERMISSION_DENIED' }, + { no: 16, name: 'ERROR_CODE_UNAUTHENTICATED' }, + { no: 8, name: 'ERROR_CODE_RESOURCE_EXHAUSTED' }, + { no: 9, name: 'ERROR_CODE_FAILED_PRECONDITION' }, + { no: 10, name: 'ERROR_CODE_ABORTED' }, + { no: 11, name: 'ERROR_CODE_OUT_OF_RANGE' }, + { no: 12, name: 'ERROR_CODE_UNIMPLEMENTED' }, + { no: 13, name: 'ERROR_CODE_INTERNAL' }, + { no: 14, name: 'ERROR_CODE_UNAVAILABLE' }, + { no: 15, name: 'ERROR_CODE_DATA_LOSS' }, + ], +); +var SetUpFirebaseRequest; +(function (SetUpFirebaseRequest2) { + SetUpFirebaseRequest2[(SetUpFirebaseRequest2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + SetUpFirebaseRequest2[(SetUpFirebaseRequest2['FORCE_SHOW_SET_UP_UI'] = 1)] = + 'FORCE_SHOW_SET_UP_UI'; + SetUpFirebaseRequest2[(SetUpFirebaseRequest2['PROVISION'] = 2)] = 'PROVISION'; +})(SetUpFirebaseRequest || (SetUpFirebaseRequest = {})); +proto3.util.setEnumType( + SetUpFirebaseRequest, + 'exa.cortex_pb.SetUpFirebaseRequest', + [ + { no: 0, name: 'SET_UP_FIREBASE_REQUEST_UNSPECIFIED' }, + { no: 1, name: 'SET_UP_FIREBASE_REQUEST_FORCE_SHOW_SET_UP_UI' }, + { no: 2, name: 'SET_UP_FIREBASE_REQUEST_PROVISION' }, + ], +); +var SetUpFirebaseResult; +(function (SetUpFirebaseResult2) { + SetUpFirebaseResult2[(SetUpFirebaseResult2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + SetUpFirebaseResult2[(SetUpFirebaseResult2['SHOW_SET_UP_UI'] = 1)] = + 'SHOW_SET_UP_UI'; + SetUpFirebaseResult2[(SetUpFirebaseResult2['IMPLEMENT_FIREBASE'] = 2)] = + 'IMPLEMENT_FIREBASE'; + SetUpFirebaseResult2[(SetUpFirebaseResult2['TOS_ERROR'] = 3)] = 'TOS_ERROR'; + SetUpFirebaseResult2[(SetUpFirebaseResult2['PROVISIONING_ERROR'] = 4)] = + 'PROVISIONING_ERROR'; +})(SetUpFirebaseResult || (SetUpFirebaseResult = {})); +proto3.util.setEnumType( + SetUpFirebaseResult, + 'exa.cortex_pb.SetUpFirebaseResult', + [ + { no: 0, name: 'SET_UP_FIREBASE_RESULT_UNSPECIFIED' }, + { no: 1, name: 'SET_UP_FIREBASE_RESULT_SHOW_SET_UP_UI' }, + { no: 2, name: 'SET_UP_FIREBASE_RESULT_IMPLEMENT_FIREBASE' }, + { no: 3, name: 'SET_UP_FIREBASE_RESULT_TOS_ERROR' }, + { no: 4, name: 'SET_UP_FIREBASE_RESULT_PROVISIONING_ERROR' }, + ], +); +var AutoRunDecision; +(function (AutoRunDecision2) { + AutoRunDecision2[(AutoRunDecision2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + AutoRunDecision2[(AutoRunDecision2['USER_ALLOW'] = 1)] = 'USER_ALLOW'; + AutoRunDecision2[(AutoRunDecision2['USER_DENY'] = 2)] = 'USER_DENY'; + AutoRunDecision2[(AutoRunDecision2['SYSTEM_ALLOW'] = 3)] = 'SYSTEM_ALLOW'; + AutoRunDecision2[(AutoRunDecision2['SYSTEM_DENY'] = 4)] = 'SYSTEM_DENY'; + AutoRunDecision2[(AutoRunDecision2['MODEL_ALLOW'] = 5)] = 'MODEL_ALLOW'; + AutoRunDecision2[(AutoRunDecision2['MODEL_DENY'] = 6)] = 'MODEL_DENY'; + AutoRunDecision2[(AutoRunDecision2['DEFAULT_ALLOW'] = 7)] = 'DEFAULT_ALLOW'; + AutoRunDecision2[(AutoRunDecision2['DEFAULT_DENY'] = 8)] = 'DEFAULT_DENY'; +})(AutoRunDecision || (AutoRunDecision = {})); +proto3.util.setEnumType(AutoRunDecision, 'exa.cortex_pb.AutoRunDecision', [ + { no: 0, name: 'AUTO_RUN_DECISION_UNSPECIFIED' }, + { no: 1, name: 'AUTO_RUN_DECISION_USER_ALLOW' }, + { no: 2, name: 'AUTO_RUN_DECISION_USER_DENY' }, + { no: 3, name: 'AUTO_RUN_DECISION_SYSTEM_ALLOW' }, + { no: 4, name: 'AUTO_RUN_DECISION_SYSTEM_DENY' }, + { no: 5, name: 'AUTO_RUN_DECISION_MODEL_ALLOW' }, + { no: 6, name: 'AUTO_RUN_DECISION_MODEL_DENY' }, + { no: 7, name: 'AUTO_RUN_DECISION_DEFAULT_ALLOW' }, + { no: 8, name: 'AUTO_RUN_DECISION_DEFAULT_DENY' }, +]); +var SearchWebType; +(function (SearchWebType2) { + SearchWebType2[(SearchWebType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + SearchWebType2[(SearchWebType2['WEB'] = 1)] = 'WEB'; + SearchWebType2[(SearchWebType2['IMAGE'] = 2)] = 'IMAGE'; +})(SearchWebType || (SearchWebType = {})); +proto3.util.setEnumType(SearchWebType, 'exa.cortex_pb.SearchWebType', [ + { no: 0, name: 'SEARCH_WEB_TYPE_UNSPECIFIED' }, + { no: 1, name: 'SEARCH_WEB_TYPE_WEB' }, + { no: 2, name: 'SEARCH_WEB_TYPE_IMAGE' }, +]); +var DeployWebAppFileUploadStatus; +(function (DeployWebAppFileUploadStatus2) { + DeployWebAppFileUploadStatus2[ + (DeployWebAppFileUploadStatus2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + DeployWebAppFileUploadStatus2[ + (DeployWebAppFileUploadStatus2['PENDING'] = 1) + ] = 'PENDING'; + DeployWebAppFileUploadStatus2[ + (DeployWebAppFileUploadStatus2['IN_PROGRESS'] = 2) + ] = 'IN_PROGRESS'; + DeployWebAppFileUploadStatus2[ + (DeployWebAppFileUploadStatus2['SUCCESS'] = 3) + ] = 'SUCCESS'; + DeployWebAppFileUploadStatus2[ + (DeployWebAppFileUploadStatus2['FAILURE'] = 4) + ] = 'FAILURE'; +})(DeployWebAppFileUploadStatus || (DeployWebAppFileUploadStatus = {})); +proto3.util.setEnumType( + DeployWebAppFileUploadStatus, + 'exa.cortex_pb.DeployWebAppFileUploadStatus', + [ + { no: 0, name: 'DEPLOY_WEB_APP_FILE_UPLOAD_STATUS_UNSPECIFIED' }, + { no: 1, name: 'DEPLOY_WEB_APP_FILE_UPLOAD_STATUS_PENDING' }, + { no: 2, name: 'DEPLOY_WEB_APP_FILE_UPLOAD_STATUS_IN_PROGRESS' }, + { no: 3, name: 'DEPLOY_WEB_APP_FILE_UPLOAD_STATUS_SUCCESS' }, + { no: 4, name: 'DEPLOY_WEB_APP_FILE_UPLOAD_STATUS_FAILURE' }, + ], +); +var ExecutorTerminationReason; +(function (ExecutorTerminationReason2) { + ExecutorTerminationReason2[(ExecutorTerminationReason2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + ExecutorTerminationReason2[(ExecutorTerminationReason2['ERROR'] = 1)] = + 'ERROR'; + ExecutorTerminationReason2[ + (ExecutorTerminationReason2['USER_CANCELED'] = 2) + ] = 'USER_CANCELED'; + ExecutorTerminationReason2[ + (ExecutorTerminationReason2['MAX_INVOCATIONS'] = 3) + ] = 'MAX_INVOCATIONS'; + ExecutorTerminationReason2[(ExecutorTerminationReason2['NO_TOOL_CALL'] = 4)] = + 'NO_TOOL_CALL'; + ExecutorTerminationReason2[ + (ExecutorTerminationReason2['MAX_FORCED_INVOCATIONS'] = 6) + ] = 'MAX_FORCED_INVOCATIONS'; + ExecutorTerminationReason2[ + (ExecutorTerminationReason2['EARLY_CONTINUE'] = 7) + ] = 'EARLY_CONTINUE'; + ExecutorTerminationReason2[ + (ExecutorTerminationReason2['TERMINAL_STEP_TYPE'] = 8) + ] = 'TERMINAL_STEP_TYPE'; + ExecutorTerminationReason2[ + (ExecutorTerminationReason2['TERMINAL_CUSTOM_HOOK'] = 9) + ] = 'TERMINAL_CUSTOM_HOOK'; + ExecutorTerminationReason2[ + (ExecutorTerminationReason2['INJECTED_RESPONSE'] = 10) + ] = 'INJECTED_RESPONSE'; +})(ExecutorTerminationReason || (ExecutorTerminationReason = {})); +proto3.util.setEnumType( + ExecutorTerminationReason, + 'exa.cortex_pb.ExecutorTerminationReason', + [ + { no: 0, name: 'EXECUTOR_TERMINATION_REASON_UNSPECIFIED' }, + { no: 1, name: 'EXECUTOR_TERMINATION_REASON_ERROR' }, + { no: 2, name: 'EXECUTOR_TERMINATION_REASON_USER_CANCELED' }, + { no: 3, name: 'EXECUTOR_TERMINATION_REASON_MAX_INVOCATIONS' }, + { no: 4, name: 'EXECUTOR_TERMINATION_REASON_NO_TOOL_CALL' }, + { no: 6, name: 'EXECUTOR_TERMINATION_REASON_MAX_FORCED_INVOCATIONS' }, + { no: 7, name: 'EXECUTOR_TERMINATION_REASON_EARLY_CONTINUE' }, + { no: 8, name: 'EXECUTOR_TERMINATION_REASON_TERMINAL_STEP_TYPE' }, + { no: 9, name: 'EXECUTOR_TERMINATION_REASON_TERMINAL_CUSTOM_HOOK' }, + { no: 10, name: 'EXECUTOR_TERMINATION_REASON_INJECTED_RESPONSE' }, + ], +); +var LintDiffType; +(function (LintDiffType2) { + LintDiffType2[(LintDiffType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + LintDiffType2[(LintDiffType2['DELETE'] = 1)] = 'DELETE'; + LintDiffType2[(LintDiffType2['INSERT'] = 2)] = 'INSERT'; + LintDiffType2[(LintDiffType2['UNCHANGED'] = 3)] = 'UNCHANGED'; +})(LintDiffType || (LintDiffType = {})); +proto3.util.setEnumType(LintDiffType, 'exa.cortex_pb.LintDiffType', [ + { no: 0, name: 'LINT_DIFF_TYPE_UNSPECIFIED' }, + { no: 1, name: 'LINT_DIFF_TYPE_DELETE' }, + { no: 2, name: 'LINT_DIFF_TYPE_INSERT' }, + { no: 3, name: 'LINT_DIFF_TYPE_UNCHANGED' }, +]); +var BrainEntryType; +(function (BrainEntryType2) { + BrainEntryType2[(BrainEntryType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + BrainEntryType2[(BrainEntryType2['PLAN'] = 1)] = 'PLAN'; + BrainEntryType2[(BrainEntryType2['TASK'] = 2)] = 'TASK'; +})(BrainEntryType || (BrainEntryType = {})); +proto3.util.setEnumType(BrainEntryType, 'exa.cortex_pb.BrainEntryType', [ + { no: 0, name: 'BRAIN_ENTRY_TYPE_UNSPECIFIED' }, + { no: 1, name: 'BRAIN_ENTRY_TYPE_PLAN' }, + { no: 2, name: 'BRAIN_ENTRY_TYPE_TASK' }, +]); +var TaskStatus; +(function (TaskStatus2) { + TaskStatus2[(TaskStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + TaskStatus2[(TaskStatus2['TODO'] = 1)] = 'TODO'; + TaskStatus2[(TaskStatus2['IN_PROGRESS'] = 2)] = 'IN_PROGRESS'; + TaskStatus2[(TaskStatus2['DONE'] = 3)] = 'DONE'; +})(TaskStatus || (TaskStatus = {})); +proto3.util.setEnumType(TaskStatus, 'exa.cortex_pb.TaskStatus', [ + { no: 0, name: 'TASK_STATUS_UNSPECIFIED' }, + { no: 1, name: 'TASK_STATUS_TODO' }, + { no: 2, name: 'TASK_STATUS_IN_PROGRESS' }, + { no: 3, name: 'TASK_STATUS_DONE' }, +]); +var TaskDeltaType; +(function (TaskDeltaType2) { + TaskDeltaType2[(TaskDeltaType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + TaskDeltaType2[(TaskDeltaType2['ADD'] = 1)] = 'ADD'; + TaskDeltaType2[(TaskDeltaType2['PRUNE'] = 2)] = 'PRUNE'; + TaskDeltaType2[(TaskDeltaType2['DELETE'] = 3)] = 'DELETE'; + TaskDeltaType2[(TaskDeltaType2['UPDATE'] = 4)] = 'UPDATE'; + TaskDeltaType2[(TaskDeltaType2['MOVE'] = 5)] = 'MOVE'; +})(TaskDeltaType || (TaskDeltaType = {})); +proto3.util.setEnumType(TaskDeltaType, 'exa.cortex_pb.TaskDeltaType', [ + { no: 0, name: 'TASK_DELTA_TYPE_UNSPECIFIED' }, + { no: 1, name: 'TASK_DELTA_TYPE_ADD' }, + { no: 2, name: 'TASK_DELTA_TYPE_PRUNE' }, + { no: 3, name: 'TASK_DELTA_TYPE_DELETE' }, + { no: 4, name: 'TASK_DELTA_TYPE_UPDATE' }, + { no: 5, name: 'TASK_DELTA_TYPE_MOVE' }, +]); +var BrainUpdateTrigger; +(function (BrainUpdateTrigger2) { + BrainUpdateTrigger2[(BrainUpdateTrigger2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + BrainUpdateTrigger2[(BrainUpdateTrigger2['SYSTEM_FORCED'] = 1)] = + 'SYSTEM_FORCED'; + BrainUpdateTrigger2[(BrainUpdateTrigger2['USER_REQUESTED'] = 2)] = + 'USER_REQUESTED'; + BrainUpdateTrigger2[(BrainUpdateTrigger2['USER_NEW_INFO'] = 3)] = + 'USER_NEW_INFO'; + BrainUpdateTrigger2[(BrainUpdateTrigger2['RESEARCH_NEW_INFO'] = 4)] = + 'RESEARCH_NEW_INFO'; +})(BrainUpdateTrigger || (BrainUpdateTrigger = {})); +proto3.util.setEnumType( + BrainUpdateTrigger, + 'exa.cortex_pb.BrainUpdateTrigger', + [ + { no: 0, name: 'BRAIN_UPDATE_TRIGGER_UNSPECIFIED' }, + { no: 1, name: 'BRAIN_UPDATE_TRIGGER_SYSTEM_FORCED' }, + { no: 2, name: 'BRAIN_UPDATE_TRIGGER_USER_REQUESTED' }, + { no: 3, name: 'BRAIN_UPDATE_TRIGGER_USER_NEW_INFO' }, + { no: 4, name: 'BRAIN_UPDATE_TRIGGER_RESEARCH_NEW_INFO' }, + ], +); +var RecordingGenerationStatus; +(function (RecordingGenerationStatus2) { + RecordingGenerationStatus2[(RecordingGenerationStatus2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + RecordingGenerationStatus2[(RecordingGenerationStatus2['GENERATING'] = 1)] = + 'GENERATING'; + RecordingGenerationStatus2[(RecordingGenerationStatus2['ERROR'] = 2)] = + 'ERROR'; + RecordingGenerationStatus2[(RecordingGenerationStatus2['COMPLETED'] = 3)] = + 'COMPLETED'; +})(RecordingGenerationStatus || (RecordingGenerationStatus = {})); +proto3.util.setEnumType( + RecordingGenerationStatus, + 'exa.cortex_pb.RecordingGenerationStatus', + [ + { no: 0, name: 'RECORDING_GENERATION_STATUS_UNSPECIFIED' }, + { no: 1, name: 'RECORDING_GENERATION_STATUS_GENERATING' }, + { no: 2, name: 'RECORDING_GENERATION_STATUS_ERROR' }, + { no: 3, name: 'RECORDING_GENERATION_STATUS_COMPLETED' }, + ], +); +var CommandOutputPriority; +(function (CommandOutputPriority2) { + CommandOutputPriority2[(CommandOutputPriority2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CommandOutputPriority2[(CommandOutputPriority2['TOP'] = 1)] = 'TOP'; + CommandOutputPriority2[(CommandOutputPriority2['BOTTOM'] = 2)] = 'BOTTOM'; + CommandOutputPriority2[(CommandOutputPriority2['SPLIT'] = 3)] = 'SPLIT'; +})(CommandOutputPriority || (CommandOutputPriority = {})); +proto3.util.setEnumType( + CommandOutputPriority, + 'exa.cortex_pb.CommandOutputPriority', + [ + { no: 0, name: 'COMMAND_OUTPUT_PRIORITY_UNSPECIFIED' }, + { no: 1, name: 'COMMAND_OUTPUT_PRIORITY_TOP' }, + { no: 2, name: 'COMMAND_OUTPUT_PRIORITY_BOTTOM' }, + { no: 3, name: 'COMMAND_OUTPUT_PRIORITY_SPLIT' }, + ], +); +var CortexMemorySource; +(function (CortexMemorySource2) { + CortexMemorySource2[(CortexMemorySource2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + CortexMemorySource2[(CortexMemorySource2['USER'] = 1)] = 'USER'; + CortexMemorySource2[(CortexMemorySource2['CASCADE'] = 2)] = 'CASCADE'; +})(CortexMemorySource || (CortexMemorySource = {})); +proto3.util.setEnumType( + CortexMemorySource, + 'exa.cortex_pb.CortexMemorySource', + [ + { no: 0, name: 'CORTEX_MEMORY_SOURCE_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_MEMORY_SOURCE_USER' }, + { no: 2, name: 'CORTEX_MEMORY_SOURCE_CASCADE' }, + ], +); +var CortexMemoryTrigger; +(function (CortexMemoryTrigger2) { + CortexMemoryTrigger2[(CortexMemoryTrigger2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CortexMemoryTrigger2[(CortexMemoryTrigger2['ALWAYS_ON'] = 1)] = 'ALWAYS_ON'; + CortexMemoryTrigger2[(CortexMemoryTrigger2['MODEL_DECISION'] = 2)] = + 'MODEL_DECISION'; + CortexMemoryTrigger2[(CortexMemoryTrigger2['MANUAL'] = 3)] = 'MANUAL'; + CortexMemoryTrigger2[(CortexMemoryTrigger2['GLOB'] = 4)] = 'GLOB'; +})(CortexMemoryTrigger || (CortexMemoryTrigger = {})); +proto3.util.setEnumType( + CortexMemoryTrigger, + 'exa.cortex_pb.CortexMemoryTrigger', + [ + { no: 0, name: 'CORTEX_MEMORY_TRIGGER_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_MEMORY_TRIGGER_ALWAYS_ON' }, + { no: 2, name: 'CORTEX_MEMORY_TRIGGER_MODEL_DECISION' }, + { no: 3, name: 'CORTEX_MEMORY_TRIGGER_MANUAL' }, + { no: 4, name: 'CORTEX_MEMORY_TRIGGER_GLOB' }, + ], +); +var MemoryActionType; +(function (MemoryActionType2) { + MemoryActionType2[(MemoryActionType2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + MemoryActionType2[(MemoryActionType2['CREATE'] = 1)] = 'CREATE'; + MemoryActionType2[(MemoryActionType2['UPDATE'] = 2)] = 'UPDATE'; + MemoryActionType2[(MemoryActionType2['DELETE'] = 3)] = 'DELETE'; +})(MemoryActionType || (MemoryActionType = {})); +proto3.util.setEnumType(MemoryActionType, 'exa.cortex_pb.MemoryActionType', [ + { no: 0, name: 'MEMORY_ACTION_TYPE_UNSPECIFIED' }, + { no: 1, name: 'MEMORY_ACTION_TYPE_CREATE' }, + { no: 2, name: 'MEMORY_ACTION_TYPE_UPDATE' }, + { no: 3, name: 'MEMORY_ACTION_TYPE_DELETE' }, +]); +var CortexStepManagerFeedbackStatus; +(function (CortexStepManagerFeedbackStatus2) { + CortexStepManagerFeedbackStatus2[ + (CortexStepManagerFeedbackStatus2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + CortexStepManagerFeedbackStatus2[ + (CortexStepManagerFeedbackStatus2['APPROVED'] = 1) + ] = 'APPROVED'; + CortexStepManagerFeedbackStatus2[ + (CortexStepManagerFeedbackStatus2['DENIED'] = 2) + ] = 'DENIED'; + CortexStepManagerFeedbackStatus2[ + (CortexStepManagerFeedbackStatus2['ERROR'] = 3) + ] = 'ERROR'; +})(CortexStepManagerFeedbackStatus || (CortexStepManagerFeedbackStatus = {})); +proto3.util.setEnumType( + CortexStepManagerFeedbackStatus, + 'exa.cortex_pb.CortexStepManagerFeedbackStatus', + [ + { no: 0, name: 'CORTEX_STEP_MANAGER_FEEDBACK_STATUS_UNSPECIFIED' }, + { no: 1, name: 'CORTEX_STEP_MANAGER_FEEDBACK_STATUS_APPROVED' }, + { no: 2, name: 'CORTEX_STEP_MANAGER_FEEDBACK_STATUS_DENIED' }, + { no: 3, name: 'CORTEX_STEP_MANAGER_FEEDBACK_STATUS_ERROR' }, + ], +); +var McpServerStatus; +(function (McpServerStatus2) { + McpServerStatus2[(McpServerStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + McpServerStatus2[(McpServerStatus2['PENDING'] = 1)] = 'PENDING'; + McpServerStatus2[(McpServerStatus2['READY'] = 2)] = 'READY'; + McpServerStatus2[(McpServerStatus2['ERROR'] = 3)] = 'ERROR'; +})(McpServerStatus || (McpServerStatus = {})); +proto3.util.setEnumType(McpServerStatus, 'exa.cortex_pb.McpServerStatus', [ + { no: 0, name: 'MCP_SERVER_STATUS_UNSPECIFIED' }, + { no: 1, name: 'MCP_SERVER_STATUS_PENDING' }, + { no: 2, name: 'MCP_SERVER_STATUS_READY' }, + { no: 3, name: 'MCP_SERVER_STATUS_ERROR' }, +]); +var EphemeralMessagePersistenceLevel; +(function (EphemeralMessagePersistenceLevel2) { + EphemeralMessagePersistenceLevel2[ + (EphemeralMessagePersistenceLevel2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + EphemeralMessagePersistenceLevel2[ + (EphemeralMessagePersistenceLevel2['ALL'] = 1) + ] = 'ALL'; + EphemeralMessagePersistenceLevel2[ + (EphemeralMessagePersistenceLevel2['LATEST_ONLY'] = 2) + ] = 'LATEST_ONLY'; +})(EphemeralMessagePersistenceLevel || (EphemeralMessagePersistenceLevel = {})); +proto3.util.setEnumType( + EphemeralMessagePersistenceLevel, + 'exa.cortex_pb.EphemeralMessagePersistenceLevel', + [ + { no: 0, name: 'EPHEMERAL_MESSAGE_PERSISTENCE_LEVEL_UNSPECIFIED' }, + { no: 1, name: 'EPHEMERAL_MESSAGE_PERSISTENCE_LEVEL_ALL' }, + { no: 2, name: 'EPHEMERAL_MESSAGE_PERSISTENCE_LEVEL_LATEST_ONLY' }, + ], +); +var BrowserEphemeralOption; +(function (BrowserEphemeralOption2) { + BrowserEphemeralOption2[(BrowserEphemeralOption2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + BrowserEphemeralOption2[(BrowserEphemeralOption2['SCREENSHOT'] = 1)] = + 'SCREENSHOT'; + BrowserEphemeralOption2[(BrowserEphemeralOption2['DOM'] = 2)] = 'DOM'; +})(BrowserEphemeralOption || (BrowserEphemeralOption = {})); +proto3.util.setEnumType( + BrowserEphemeralOption, + 'exa.cortex_pb.BrowserEphemeralOption', + [ + { no: 0, name: 'BROWSER_EPHEMERAL_OPTION_UNSPECIFIED' }, + { no: 1, name: 'BROWSER_EPHEMERAL_OPTION_SCREENSHOT' }, + { no: 2, name: 'BROWSER_EPHEMERAL_OPTION_DOM' }, + ], +); +var TrajectoryShareStatus; +(function (TrajectoryShareStatus2) { + TrajectoryShareStatus2[(TrajectoryShareStatus2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + TrajectoryShareStatus2[(TrajectoryShareStatus2['TEAM'] = 1)] = 'TEAM'; +})(TrajectoryShareStatus || (TrajectoryShareStatus = {})); +proto3.util.setEnumType( + TrajectoryShareStatus, + 'exa.cortex_pb.TrajectoryShareStatus', + [ + { no: 0, name: 'TRAJECTORY_SHARE_STATUS_UNSPECIFIED' }, + { no: 1, name: 'TRAJECTORY_SHARE_STATUS_TEAM' }, + ], +); +var RunExtensionCodeAutoRunDecision; +(function (RunExtensionCodeAutoRunDecision2) { + RunExtensionCodeAutoRunDecision2[ + (RunExtensionCodeAutoRunDecision2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + RunExtensionCodeAutoRunDecision2[ + (RunExtensionCodeAutoRunDecision2['ALLOWED'] = 1) + ] = 'ALLOWED'; + RunExtensionCodeAutoRunDecision2[ + (RunExtensionCodeAutoRunDecision2['DENIED'] = 2) + ] = 'DENIED'; + RunExtensionCodeAutoRunDecision2[ + (RunExtensionCodeAutoRunDecision2['MODEL_ALLOWED'] = 3) + ] = 'MODEL_ALLOWED'; + RunExtensionCodeAutoRunDecision2[ + (RunExtensionCodeAutoRunDecision2['MODEL_DENIED'] = 4) + ] = 'MODEL_DENIED'; +})(RunExtensionCodeAutoRunDecision || (RunExtensionCodeAutoRunDecision = {})); +proto3.util.setEnumType( + RunExtensionCodeAutoRunDecision, + 'exa.cortex_pb.RunExtensionCodeAutoRunDecision', + [ + { no: 0, name: 'RUN_EXTENSION_CODE_AUTO_RUN_DECISION_UNSPECIFIED' }, + { no: 1, name: 'RUN_EXTENSION_CODE_AUTO_RUN_DECISION_ALLOWED' }, + { no: 2, name: 'RUN_EXTENSION_CODE_AUTO_RUN_DECISION_DENIED' }, + { no: 3, name: 'RUN_EXTENSION_CODE_AUTO_RUN_DECISION_MODEL_ALLOWED' }, + { no: 4, name: 'RUN_EXTENSION_CODE_AUTO_RUN_DECISION_MODEL_DENIED' }, + ], +); +var TrajectorySearchIdType; +(function (TrajectorySearchIdType2) { + TrajectorySearchIdType2[(TrajectorySearchIdType2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + TrajectorySearchIdType2[(TrajectorySearchIdType2['CASCADE_ID'] = 1)] = + 'CASCADE_ID'; + TrajectorySearchIdType2[(TrajectorySearchIdType2['MAINLINE'] = 2)] = + 'MAINLINE'; +})(TrajectorySearchIdType || (TrajectorySearchIdType = {})); +proto3.util.setEnumType( + TrajectorySearchIdType, + 'exa.cortex_pb.TrajectorySearchIdType', + [ + { no: 0, name: 'TRAJECTORY_SEARCH_ID_TYPE_UNSPECIFIED' }, + { no: 1, name: 'TRAJECTORY_SEARCH_ID_TYPE_CASCADE_ID' }, + { no: 2, name: 'TRAJECTORY_SEARCH_ID_TYPE_MAINLINE' }, + ], +); +var CodeAcknowledgementScope; +(function (CodeAcknowledgementScope2) { + CodeAcknowledgementScope2[(CodeAcknowledgementScope2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + CodeAcknowledgementScope2[(CodeAcknowledgementScope2['FILE'] = 1)] = 'FILE'; + CodeAcknowledgementScope2[(CodeAcknowledgementScope2['ALL'] = 2)] = 'ALL'; + CodeAcknowledgementScope2[(CodeAcknowledgementScope2['HUNK'] = 3)] = 'HUNK'; +})(CodeAcknowledgementScope || (CodeAcknowledgementScope = {})); +proto3.util.setEnumType( + CodeAcknowledgementScope, + 'exa.cortex_pb.CodeAcknowledgementScope', + [ + { no: 0, name: 'CODE_ACKNOWLEDGEMENT_SCOPE_UNSPECIFIED' }, + { no: 1, name: 'CODE_ACKNOWLEDGEMENT_SCOPE_FILE' }, + { no: 2, name: 'CODE_ACKNOWLEDGEMENT_SCOPE_ALL' }, + { no: 3, name: 'CODE_ACKNOWLEDGEMENT_SCOPE_HUNK' }, + ], +); +var ArtifactReviewStatus; +(function (ArtifactReviewStatus2) { + ArtifactReviewStatus2[(ArtifactReviewStatus2['UNSPECIFIED'] = 0)] = + 'UNSPECIFIED'; + ArtifactReviewStatus2[(ArtifactReviewStatus2['PENDING_REVIEW'] = 1)] = + 'PENDING_REVIEW'; + ArtifactReviewStatus2[(ArtifactReviewStatus2['REVIEWED'] = 2)] = 'REVIEWED'; + ArtifactReviewStatus2[(ArtifactReviewStatus2['MODIFIED'] = 3)] = 'MODIFIED'; +})(ArtifactReviewStatus || (ArtifactReviewStatus = {})); +proto3.util.setEnumType( + ArtifactReviewStatus, + 'exa.cortex_pb.ArtifactReviewStatus', + [ + { no: 0, name: 'ARTIFACT_REVIEW_STATUS_UNSPECIFIED' }, + { no: 1, name: 'ARTIFACT_REVIEW_STATUS_PENDING_REVIEW' }, + { no: 2, name: 'ARTIFACT_REVIEW_STATUS_REVIEWED' }, + { no: 3, name: 'ARTIFACT_REVIEW_STATUS_MODIFIED' }, + ], +); +var WorkflowSpec = class _WorkflowSpec extends Message { + /** + * Path to the workflow file. + * + * @generated from field: string path = 1; + */ + path = ''; + /** + * Name of the workflow. + * + * @generated from field: string name = 2; + */ + name = ''; + /** + * Human-readable description (also used by model) + * + * @generated from field: string description = 3; + */ + description = ''; + /** + * Full content of the workflow. + * + * @generated from field: string content = 4; + */ + content = ''; + /** + * Whether to auto-run commands in this workflow. + * + * @generated from field: bool turbo = 5; + */ + turbo = false; + /** + * Whether this workflow is a built-in. + * + * @generated from field: bool is_builtin = 6; + */ + isBuiltin = false; + /** + * Scope of this workflow + * + * @generated from field: exa.cortex_pb.CortexMemoryScope scope = 7; + */ + scope; + /** + * Base directory of this workflow + * + * @generated from field: string base_dir = 8; + */ + baseDir = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.WorkflowSpec'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'turbo', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'is_builtin', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 7, name: 'scope', kind: 'message', T: CortexMemoryScope }, + { + no: 8, + name: 'base_dir', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _WorkflowSpec().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WorkflowSpec().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WorkflowSpec().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_WorkflowSpec, a, b); + } +}; +var CortexPlanSummaryComponent = class _CortexPlanSummaryComponent extends Message { + /** + * @generated from oneof exa.cortex_pb.CortexPlanSummaryComponent.component + */ + component = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexPlanSummaryComponent'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'text', kind: 'scalar', T: 9, oneof: 'component' }, + { + no: 2, + name: 'citation', + kind: 'message', + T: ContextScopeItem, + oneof: 'component', + }, + ]); + static fromBinary(bytes, options) { + return new _CortexPlanSummaryComponent().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexPlanSummaryComponent().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexPlanSummaryComponent().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexPlanSummaryComponent, a, b); + } +}; +var CodingStepState = class _CodingStepState extends Message { + /** + * @generated from field: string plan_id = 1; + */ + planId = ''; + /** + * @generated from field: string goal = 2; + */ + goal = ''; + /** + * @generated from field: repeated exa.cortex_pb.ActionState action_states = 3; + */ + actionStates = []; + /** + * @generated from field: repeated exa.cortex_pb.CortexStepOutline outlines = 7; + */ + outlines = []; + /** + * @generated from field: repeated exa.cortex_pb.CortexPlanSummaryComponent summary_components = 8; + */ + summaryComponents = []; + /** + * @generated from field: string post_summary_text = 9; + */ + postSummaryText = ''; + /** + * Whether all steps of the coding plan are generated. + * + * @generated from field: bool plan_fully_generated = 4; + */ + planFullyGenerated = false; + /** + * Whether user has marked the plan as complete. + * + * @generated from field: bool plan_finished = 5; + */ + planFinished = false; + /** + * @generated from field: exa.cortex_pb.PlanDebugInfo debug_info = 6; + */ + debugInfo; + /** + * @generated from field: bool plan_summary_confirmed = 10; + */ + planSummaryConfirmed = false; + /** + * @generated from field: bool plan_summary_fully_generated = 11; + */ + planSummaryFullyGenerated = false; + /** + * @generated from field: repeated exa.context_module_pb.CciWithSubrangeWithRetrievalMetadata cci_list = 12; + */ + cciList = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CodingStepState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'plan_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'goal', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'action_states', + kind: 'message', + T: ActionState, + repeated: true, + }, + { + no: 7, + name: 'outlines', + kind: 'message', + T: CortexStepOutline, + repeated: true, + }, + { + no: 8, + name: 'summary_components', + kind: 'message', + T: CortexPlanSummaryComponent, + repeated: true, + }, + { + no: 9, + name: 'post_summary_text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'plan_fully_generated', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'plan_finished', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 6, name: 'debug_info', kind: 'message', T: PlanDebugInfo }, + { + no: 10, + name: 'plan_summary_confirmed', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 11, + name: 'plan_summary_fully_generated', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 12, + name: 'cci_list', + kind: 'message', + T: CciWithSubrangeWithRetrievalMetadata, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CodingStepState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodingStepState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodingStepState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodingStepState, a, b); + } +}; +var CortexPlanState = class _CortexPlanState extends Message { + /** + * @generated from field: repeated exa.cortex_pb.CortexStepState steps = 1; + */ + steps = []; + /** + * Outline will be populated while the plan is generated. + * + * @generated from field: repeated exa.cortex_pb.CortexStepOutline outlines = 2; + */ + outlines = []; + /** + * @generated from field: uint32 current_step_index = 3; + */ + currentStepIndex = 0; + /** + * @generated from field: exa.cortex_pb.PlanDebugInfo debug_info = 4; + */ + debugInfo; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexPlanState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'steps', + kind: 'message', + T: CortexStepState, + repeated: true, + }, + { + no: 2, + name: 'outlines', + kind: 'message', + T: CortexStepOutline, + repeated: true, + }, + { + no: 3, + name: 'current_step_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 4, name: 'debug_info', kind: 'message', T: PlanDebugInfo }, + ]); + static fromBinary(bytes, options) { + return new _CortexPlanState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexPlanState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexPlanState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexPlanState, a, b); + } +}; +var CortexStepOutline = class _CortexStepOutline extends Message { + /** + * Step numbers are 1-indexed. + * + * @generated from field: uint32 step_number = 1; + */ + stepNumber = 0; + /** + * @generated from field: string action_name = 2; + */ + actionName = ''; + /** + * @generated from field: string json_args = 3; + */ + jsonArgs = ''; + /** + * @generated from field: repeated uint32 parent_step_numbers = 4; + */ + parentStepNumbers = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepOutline'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'step_number', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'action_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'json_args', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'parent_step_numbers', + kind: 'scalar', + T: 13, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepOutline().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepOutline().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepOutline().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepOutline, a, b); + } +}; +var CortexStepState = class _CortexStepState extends Message { + /** + * @generated from oneof exa.cortex_pb.CortexStepState.step + */ + step = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'coding', + kind: 'message', + T: CodingStepState, + oneof: 'step', + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepState, a, b); + } +}; +var CortexResearchState = class _CortexResearchState extends Message { + /** + * @generated from field: uint32 total_retrieved_count = 1; + */ + totalRetrievedCount = 0; + /** + * TODO(matt): Eventually, this will be a map from query to research result. + * TODO(matt): Once we have research steps, decide what goes into the research + * state vs a research step state. + * + * @generated from field: repeated exa.codeium_common_pb.CciWithSubrange top_retrieved_items = 2; + */ + topRetrievedItems = []; + /** + * Only populated in offline usages. + * + * @generated from field: exa.cortex_pb.ResearchDebugInfo debug_info = 3; + */ + debugInfo; + /** + * @generated from field: repeated exa.codeium_common_pb.CciWithSubrange full_cci_list = 4; + */ + fullCciList = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexResearchState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'total_retrieved_count', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'top_retrieved_items', + kind: 'message', + T: CciWithSubrange, + repeated: true, + }, + { no: 3, name: 'debug_info', kind: 'message', T: ResearchDebugInfo }, + { + no: 4, + name: 'full_cci_list', + kind: 'message', + T: CciWithSubrange, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexResearchState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexResearchState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexResearchState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexResearchState, a, b); + } +}; +var ResearchDebugInfo = class _ResearchDebugInfo extends Message { + /** + * @generated from field: string query = 1; + */ + query = ''; + /** + * List of relative paths of files considered by the query. + * + * @generated from field: repeated string files_scanned = 2; + */ + filesScanned = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ResearchDebugInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'files_scanned', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _ResearchDebugInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ResearchDebugInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ResearchDebugInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ResearchDebugInfo, a, b); + } +}; +var CortexWorkflowState = class _CortexWorkflowState extends Message { + /** + * Where the cortex request came from. + * + * @generated from field: exa.cortex_pb.CortexRequestSource request_source = 6; + */ + requestSource = CortexRequestSource.UNSPECIFIED; + /** + * Input state. + * + * @generated from field: string goal = 1; + */ + goal = ''; + /** + * @generated from field: exa.cortex_pb.PlanInput plan_input = 2; + */ + planInput; + /** + * Research state. + * + * @generated from field: exa.cortex_pb.CortexResearchState research_state = 3; + */ + researchState; + /** + * Macro-plan state. + * + * @generated from field: exa.cortex_pb.CortexPlanState plan_state = 4; + */ + planState; + /** + * Error state. + * TODO(matt): Consider moving this up a level. + * + * @generated from field: string error = 5; + */ + error = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexWorkflowState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 6, + name: 'request_source', + kind: 'enum', + T: proto3.getEnumType(CortexRequestSource), + }, + { + no: 1, + name: 'goal', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'plan_input', kind: 'message', T: PlanInput }, + { no: 3, name: 'research_state', kind: 'message', T: CortexResearchState }, + { no: 4, name: 'plan_state', kind: 'message', T: CortexPlanState }, + { + no: 5, + name: 'error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexWorkflowState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexWorkflowState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexWorkflowState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexWorkflowState, a, b); + } +}; +var CortexRunState = class _CortexRunState extends Message { + /** + * Workflow state contains all of the cortex-specific information + * and context accumulated throughout the execution. + * + * @generated from field: exa.cortex_pb.CortexWorkflowState workflow_state = 1; + */ + workflowState; + /** + * Execution state contains generic information about the graph execution. + * + * @generated from field: exa.codeium_common_pb.GraphExecutionState execution_state = 2; + */ + executionState; + /** + * Cortex graph is done executing. + * + * @generated from field: bool done = 3; + */ + done = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexRunState'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'workflow_state', kind: 'message', T: CortexWorkflowState }, + { no: 2, name: 'execution_state', kind: 'message', T: GraphExecutionState }, + { + no: 3, + name: 'done', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexRunState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexRunState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexRunState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexRunState, a, b); + } +}; +var PlanInput = class _PlanInput extends Message { + /** + * @generated from field: string goal = 1; + */ + goal = ''; + /** + * @generated from field: repeated string next_steps = 5; + */ + nextSteps = []; + /** + * Absolute path of target directories to retrieve context over for planning. + * + * @generated from field: repeated string target_directories = 2; + */ + targetDirectories = []; + /** + * @generated from field: repeated string target_files = 3; + */ + targetFiles = []; + /** + * Optionally provided. + * + * @generated from field: repeated exa.codeium_common_pb.ContextScopeItem scope_items = 4; + */ + scopeItems = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.PlanInput'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'goal', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'next_steps', kind: 'scalar', T: 9, repeated: true }, + { no: 2, name: 'target_directories', kind: 'scalar', T: 9, repeated: true }, + { no: 3, name: 'target_files', kind: 'scalar', T: 9, repeated: true }, + { + no: 4, + name: 'scope_items', + kind: 'message', + T: ContextScopeItem, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _PlanInput().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PlanInput().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PlanInput().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PlanInput, a, b); + } +}; +var ActionSpec = class _ActionSpec extends Message { + /** + * @generated from oneof exa.cortex_pb.ActionSpec.spec + */ + spec = { case: void 0 }; + /** + * @generated from field: repeated uint32 parent_step_indices = 3; + */ + parentStepIndices = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ActionSpec'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'command', + kind: 'message', + T: ActionSpecCommand, + oneof: 'spec', + }, + { + no: 2, + name: 'create_file', + kind: 'message', + T: ActionSpecCreateFile, + oneof: 'spec', + }, + { + no: 4, + name: 'delete_file', + kind: 'message', + T: ActionSpecDeleteFile, + oneof: 'spec', + }, + { + no: 3, + name: 'parent_step_indices', + kind: 'scalar', + T: 13, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ActionSpec().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActionSpec().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActionSpec().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ActionSpec, a, b); + } +}; +var ActionSpecCreateFile = class _ActionSpecCreateFile extends Message { + /** + * @generated from field: string instruction = 1; + */ + instruction = ''; + /** + * @generated from field: exa.codeium_common_pb.PathScopeItem path = 2; + */ + path; + /** + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem reference_ccis = 3; + */ + referenceCcis = []; + /** + * @generated from field: bool overwrite = 4; + */ + overwrite = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ActionSpecCreateFile'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'instruction', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'path', kind: 'message', T: PathScopeItem }, + { + no: 3, + name: 'reference_ccis', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + { + no: 4, + name: 'overwrite', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ActionSpecCreateFile().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActionSpecCreateFile().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActionSpecCreateFile().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ActionSpecCreateFile, a, b); + } +}; +var ActionSpecDeleteFile = class _ActionSpecDeleteFile extends Message { + /** + * @generated from field: exa.codeium_common_pb.PathScopeItem path = 1; + */ + path; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ActionSpecDeleteFile'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'path', kind: 'message', T: PathScopeItem }, + ]); + static fromBinary(bytes, options) { + return new _ActionSpecDeleteFile().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActionSpecDeleteFile().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActionSpecDeleteFile().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ActionSpecDeleteFile, a, b); + } +}; +var LineRangeTarget = class _LineRangeTarget extends Message { + /** + * @generated from field: string absolute_uri = 1; + */ + absoluteUri = ''; + /** + * @generated from field: uint32 start_line = 2; + */ + startLine = 0; + /** + * Exclusive + * + * @generated from field: uint32 end_line = 3; + */ + endLine = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.LineRangeTarget'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'start_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'end_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _LineRangeTarget().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LineRangeTarget().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LineRangeTarget().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LineRangeTarget, a, b); + } +}; +var CommandContentTarget = class _CommandContentTarget extends Message { + /** + * @generated from field: string content = 1; + */ + content = ''; + /** + * @generated from field: string absolute_uri = 2; + */ + absoluteUri = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CommandContentTarget'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CommandContentTarget().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CommandContentTarget().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CommandContentTarget().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CommandContentTarget, a, b); + } +}; +var ReplacementChunk = class _ReplacementChunk extends Message { + /** + * @generated from field: string target_content = 1; + */ + targetContent = ''; + /** + * @generated from field: string replacement_content = 2; + */ + replacementContent = ''; + /** + * @generated from field: bool allow_multiple = 3; + */ + allowMultiple = false; + /** + * @generated from field: bool target_has_carriage_return = 4; + */ + targetHasCarriageReturn = false; + /** + * Only used by the apply_patch variant. The model can specify context lines + * with the "@@" prefix to specify the target's scope. The handler will search + * for the target content after these lines. + * + * @generated from field: repeated string context_lines = 5; + */ + contextLines = []; + /** + * 1-indexed, inclusive. 0 is treated as 1. + * + * @generated from field: int32 start_line = 6; + */ + startLine = 0; + /** + * 1-indexed, inclusive. 0 is treated as n, where n is + * + * @generated from field: int32 end_line = 7; + */ + endLine = 0; + /** + * the number of lines in the file. + * + * @generated from field: exa.cortex_pb.AcknowledgementType acknowledgement_type = 11; + */ + acknowledgementType = AcknowledgementType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ReplacementChunk'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'target_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'replacement_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'allow_multiple', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'target_has_carriage_return', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 5, name: 'context_lines', kind: 'scalar', T: 9, repeated: true }, + { + no: 6, + name: 'start_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 7, + name: 'end_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 11, + name: 'acknowledgement_type', + kind: 'enum', + T: proto3.getEnumType(AcknowledgementType), + }, + ]); + static fromBinary(bytes, options) { + return new _ReplacementChunk().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ReplacementChunk().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ReplacementChunk().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ReplacementChunk, a, b); + } +}; +var ActionSpecCommand = class _ActionSpecCommand extends Message { + /** + * @generated from field: string instruction = 1; + */ + instruction = ''; + /** + * @generated from field: repeated exa.cortex_pb.ReplacementChunk replacement_chunks = 9; + */ + replacementChunks = []; + /** + * @generated from field: bool is_edit = 2; + */ + isEdit = false; + /** + * @generated from field: bool use_fast_apply = 8; + */ + useFastApply = false; + /** + * @generated from oneof exa.cortex_pb.ActionSpecCommand.target + */ + target = { case: void 0 }; + /** + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem reference_ccis = 5; + */ + referenceCcis = []; + /** + * Classification of the edit for interactive cascade (e.g. continuing user's + * work, bug fix) + * + * @generated from field: string classification = 11; + */ + classification = ''; + /** + * Importance of the edit proposed by interactive cascade (e.g. high, medium, + * low) + * + * @generated from field: exa.cortex_pb.InteractiveCascadeEditImportance importance = 12; + */ + importance = InteractiveCascadeEditImportance.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ActionSpecCommand'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'instruction', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'replacement_chunks', + kind: 'message', + T: ReplacementChunk, + repeated: true, + }, + { + no: 2, + name: 'is_edit', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 8, + name: 'use_fast_apply', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'code_context', + kind: 'message', + T: CodeContextItem, + oneof: 'target', + }, + { no: 4, name: 'file', kind: 'message', T: PathScopeItem, oneof: 'target' }, + { + no: 6, + name: 'cci_with_subrange', + kind: 'message', + T: CciWithSubrange, + oneof: 'target', + }, + { + no: 7, + name: 'line_range', + kind: 'message', + T: LineRangeTarget, + oneof: 'target', + }, + { + no: 10, + name: 'content_target', + kind: 'message', + T: CommandContentTarget, + oneof: 'target', + }, + { + no: 5, + name: 'reference_ccis', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + { + no: 11, + name: 'classification', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'importance', + kind: 'enum', + T: proto3.getEnumType(InteractiveCascadeEditImportance), + }, + ]); + static fromBinary(bytes, options) { + return new _ActionSpecCommand().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActionSpecCommand().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActionSpecCommand().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ActionSpecCommand, a, b); + } +}; +var ActionState = class _ActionState extends Message { + /** + * @generated from field: string step_id = 5; + */ + stepId = ''; + /** + * @generated from field: exa.cortex_pb.ActionStatus status = 1; + */ + status = ActionStatus.UNSPECIFIED; + /** + * @generated from field: exa.cortex_pb.ActionSpec spec = 2; + */ + spec; + /** + * Optional information about the side-effects produced by this action. + * + * @generated from field: exa.cortex_pb.ActionResult result = 3; + */ + result; + /** + * @generated from field: string error = 4; + */ + error = ''; + /** + * Incremented when action is edited by the user in any way. + * + * @generated from field: uint32 step_version = 6; + */ + stepVersion = 0; + /** + * Incremented when the coding plan is re-planned. + * + * @generated from field: uint32 plan_version = 7; + */ + planVersion = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ActionState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 5, + name: 'step_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 1, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(ActionStatus), + }, + { no: 2, name: 'spec', kind: 'message', T: ActionSpec }, + { no: 3, name: 'result', kind: 'message', T: ActionResult }, + { + no: 4, + name: 'error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'step_version', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 7, + name: 'plan_version', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ActionState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActionState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActionState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ActionState, a, b); + } +}; +var ActionResult = class _ActionResult extends Message { + /** + * @generated from oneof exa.cortex_pb.ActionResult.result + */ + result = { case: void 0 }; + /** + * If true and action_result is not empty, will not overwrite the result but + * rather just apply it directly + * + * @generated from field: bool apply_existing_result = 2; + */ + applyExistingResult = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ActionResult'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'edit', + kind: 'message', + T: ActionResultEdit, + oneof: 'result', + }, + { + no: 2, + name: 'apply_existing_result', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ActionResult().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActionResult().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActionResult().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ActionResult, a, b); + } +}; +var ActionDebugInfo = class _ActionDebugInfo extends Message { + /** + * @generated from field: repeated exa.cortex_pb.ActionDebugInfo.DebugInfoEntry entries = 1; + */ + entries = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ActionDebugInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'entries', + kind: 'message', + T: ActionDebugInfo_DebugInfoEntry, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ActionDebugInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActionDebugInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActionDebugInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ActionDebugInfo, a, b); + } +}; +var ActionDebugInfo_DebugInfoEntry = class _ActionDebugInfo_DebugInfoEntry extends Message { + /** + * @generated from field: string key = 1; + */ + key = ''; + /** + * @generated from field: string value = 2; + */ + value = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ActionDebugInfo.DebugInfoEntry'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'value', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ActionDebugInfo_DebugInfoEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActionDebugInfo_DebugInfoEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActionDebugInfo_DebugInfoEntry().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ActionDebugInfo_DebugInfoEntry, a, b); + } +}; +var ActionResultEdit = class _ActionResultEdit extends Message { + /** + * @generated from field: string absolute_path_migrate_me_to_uri = 1 [deprecated = true]; + * @deprecated + */ + absolutePathMigrateMeToUri = ''; + /** + * @generated from field: exa.diff_action_pb.DiffBlock diff = 2; + */ + diff; + /** + * @generated from field: string context_prefix = 3; + */ + contextPrefix = ''; + /** + * @generated from field: string context_suffix = 4; + */ + contextSuffix = ''; + /** + * @generated from field: exa.cortex_pb.ActionDebugInfo debug_info = 5; + */ + debugInfo; + /** + * this is the id of the prompt that was input into the model + * + * @generated from field: string prompt_id = 12; + */ + promptId = ''; + /** + * this is the id of the completion generated from the model + * + * @generated from field: string completion_id = 6; + */ + completionId = ''; + /** + * This is the sha256 hash of the file contents at the time the diff was + * generated. This is used to check for staleness of the diff to see if it can + * still be applied properly. + * + * @generated from field: string file_content_hash = 7; + */ + fileContentHash = ''; + /** + * @generated from field: string absolute_uri = 8; + */ + absoluteUri = ''; + /** + * Result CCIs are currently not populated. + * + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem result_ccis = 9; + */ + resultCcis = []; + /** + * Full content of the file prior to applying the diff. + * + * @generated from field: string original_content = 10; + */ + originalContent = ''; + /** + * @generated from field: bool create_file = 11; + */ + createFile = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ActionResultEdit'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_path_migrate_me_to_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'diff', kind: 'message', T: DiffBlock }, + { + no: 3, + name: 'context_prefix', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'context_suffix', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'debug_info', kind: 'message', T: ActionDebugInfo }, + { + no: 12, + name: 'prompt_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'completion_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'file_content_hash', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'result_ccis', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + { + no: 10, + name: 'original_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 11, + name: 'create_file', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ActionResultEdit().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActionResultEdit().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActionResultEdit().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ActionResultEdit, a, b); + } +}; +var RetrievalStatus = class _RetrievalStatus extends Message { + /** + * @generated from field: uint32 total_retrieved_count = 1; + */ + totalRetrievedCount = 0; + /** + * @generated from field: repeated exa.codeium_common_pb.CciWithSubrange top_retrieved_items = 2; + */ + topRetrievedItems = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.RetrievalStatus'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'total_retrieved_count', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'top_retrieved_items', + kind: 'message', + T: CciWithSubrange, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _RetrievalStatus().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RetrievalStatus().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RetrievalStatus().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RetrievalStatus, a, b); + } +}; +var PlanState = class _PlanState extends Message { + /** + * @generated from field: exa.cortex_pb.PlanStatus status = 4; + */ + status = PlanStatus2.UNSPECIFIED; + /** + * @generated from field: string plan_id = 1; + */ + planId = ''; + /** + * @generated from field: exa.cortex_pb.PlanInput plan_input = 2; + */ + planInput; + /** + * @generated from field: repeated exa.cortex_pb.ActionState actions = 3; + */ + actions = []; + /** + * @generated from field: exa.cortex_pb.RetrievalStatus retrieval_status = 6; + */ + retrievalStatus; + /** + * @generated from field: string error = 5; + */ + error = ''; + /** + * @generated from field: exa.cortex_pb.PlanDebugInfo debug_info = 7; + */ + debugInfo; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.PlanState'; + static fields = proto3.util.newFieldList(() => [ + { no: 4, name: 'status', kind: 'enum', T: proto3.getEnumType(PlanStatus2) }, + { + no: 1, + name: 'plan_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'plan_input', kind: 'message', T: PlanInput }, + { no: 3, name: 'actions', kind: 'message', T: ActionState, repeated: true }, + { no: 6, name: 'retrieval_status', kind: 'message', T: RetrievalStatus }, + { + no: 5, + name: 'error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 7, name: 'debug_info', kind: 'message', T: PlanDebugInfo }, + ]); + static fromBinary(bytes, options) { + return new _PlanState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PlanState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PlanState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PlanState, a, b); + } +}; +var PlanDebugInfo = class _PlanDebugInfo extends Message { + /** + * @generated from field: string raw_response = 1; + */ + rawResponse = ''; + /** + * @generated from field: uint32 plan_tokens = 2; + */ + planTokens = 0; + /** + * @generated from field: float plan_cost = 3; + */ + planCost = 0; + /** + * @generated from field: string system_prompt = 4; + */ + systemPrompt = ''; + /** + * @generated from field: repeated exa.chat_pb.ChatMessagePrompt message_prompts = 5; + */ + messagePrompts = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.PlanDebugInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'raw_response', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'plan_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'plan_cost', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 4, + name: 'system_prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'message_prompts', + kind: 'message', + T: ChatMessagePrompt, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _PlanDebugInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PlanDebugInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PlanDebugInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PlanDebugInfo, a, b); + } +}; +var CortexPlanConfig = class _CortexPlanConfig extends Message { + /** + * @generated from field: exa.codeium_common_pb.ChatNodeConfig model_config = 1; + */ + modelConfig; + /** + * Nominal continuations unconditionally requests the planner to add more + * steps. + * + * @generated from field: uint32 max_nominal_continuations = 2; + */ + maxNominalContinuations = 0; + /** + * Error continuation is triggered when a step is failed to be parsed. + * + * @generated from field: uint32 max_error_continuations = 3; + */ + maxErrorContinuations = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexPlanConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'model_config', kind: 'message', T: ChatNodeConfig }, + { + no: 2, + name: 'max_nominal_continuations', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'max_error_continuations', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexPlanConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexPlanConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexPlanConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexPlanConfig, a, b); + } +}; +var CortexConfig = class _CortexConfig extends Message { + /** + * Overall configurations. + * + * @generated from field: bool record_telemetry = 11; + */ + recordTelemetry = false; + /** + * [Node: distill] + * + * @generated from field: bool add_distill_node = 6; + */ + addDistillNode = false; + /** + * @generated from field: exa.codeium_common_pb.ChatNodeConfig distill_config = 10; + */ + distillConfig; + /** + * [Node: research] + * + * @generated from field: exa.codeium_common_pb.MQueryConfig m_query_config = 8; + */ + mQueryConfig; + /** + * @generated from field: string m_query_model_name = 12; + */ + mQueryModelName = ''; + /** + * [Node: macro_planner] + * + * @generated from field: bool use_macro_planner = 1; + */ + useMacroPlanner = false; + /** + * @generated from field: exa.cortex_pb.CortexPlanConfig macro_plan_config = 4; + */ + macroPlanConfig; + /** + * [Node: coder] + * This is only ingested by the individual CodePlan actions. + * + * @generated from field: exa.cortex_pb.PlanConfig plan_config = 9; + */ + planConfig; + /** + * [Node: coder.code_planner] + * + * @generated from field: exa.cortex_pb.CortexPlanConfig code_plan_config = 5; + */ + codePlanConfig; + /** + * [Node: coder.prepare_apply_all]. + * + * Replaces [Node: coder.wait_finish] with + * + * @generated from field: bool auto_prepare_apply = 2; + */ + autoPrepareApply = false; + /** + * [Node: coder.prepare_apply_all] + * + * Number of times to automatically retry preparing actions. Only + * + * @generated from field: uint32 num_prepare_retries = 3; + */ + numPrepareRetries = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 11, + name: 'record_telemetry', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'add_distill_node', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 10, name: 'distill_config', kind: 'message', T: ChatNodeConfig }, + { no: 8, name: 'm_query_config', kind: 'message', T: MQueryConfig }, + { + no: 12, + name: 'm_query_model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 1, + name: 'use_macro_planner', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 4, name: 'macro_plan_config', kind: 'message', T: CortexPlanConfig }, + { no: 9, name: 'plan_config', kind: 'message', T: PlanConfig }, + { no: 5, name: 'code_plan_config', kind: 'message', T: CortexPlanConfig }, + { + no: 2, + name: 'auto_prepare_apply', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'num_prepare_retries', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexConfig, a, b); + } +}; +var PlanConfig = class _PlanConfig extends Message { + /** + * @generated from field: string plan_model_name = 1; + */ + planModelName = ''; + /** + * @generated from field: uint32 max_tokens_per_plan = 2; + */ + maxTokensPerPlan = 0; + /** + * @generated from field: float max_token_fraction = 3; + */ + maxTokenFraction = 0; + /** + * @generated from field: float chat_temperature = 4; + */ + chatTemperature = 0; + /** + * @generated from field: uint64 chat_completion_max_tokens = 5; + */ + chatCompletionMaxTokens = protoInt64.zero; + /** + * @generated from field: bool augment_command = 9; + */ + augmentCommand = false; + /** + * @generated from field: exa.codeium_common_pb.ExperimentConfig experiment_config = 7; + */ + experimentConfig; + /** + * @generated from field: exa.codeium_common_pb.MQueryConfig m_query_config = 8; + */ + mQueryConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.PlanConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'plan_model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'max_tokens_per_plan', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'max_token_fraction', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 4, + name: 'chat_temperature', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 5, + name: 'chat_completion_max_tokens', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 9, + name: 'augment_command', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 7, name: 'experiment_config', kind: 'message', T: ExperimentConfig }, + { no: 8, name: 'm_query_config', kind: 'message', T: MQueryConfig }, + ]); + static fromBinary(bytes, options) { + return new _PlanConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PlanConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PlanConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PlanConfig, a, b); + } +}; +var CortexPlanSummary = class _CortexPlanSummary extends Message { + /** + * @generated from field: string cortex_id = 1; + */ + cortexId = ''; + /** + * @generated from field: exa.cortex_pb.PlanInput plan_input = 2; + */ + planInput; + /** + * @generated from field: google.protobuf.Timestamp created_at = 3; + */ + createdAt; + /** + * @generated from field: bool done = 4; + */ + done = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexPlanSummary'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'cortex_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'plan_input', kind: 'message', T: PlanInput }, + { no: 3, name: 'created_at', kind: 'message', T: Timestamp }, + { + no: 4, + name: 'done', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexPlanSummary().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexPlanSummary().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexPlanSummary().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexPlanSummary, a, b); + } +}; +var WorkspaceInitializationData = class _WorkspaceInitializationData extends Message { + /** + * @generated from field: exa.cortex_pb.WorkspaceType workspace_type = 1; + */ + workspaceType = WorkspaceType.UNSPECIFIED; + /** + * @generated from oneof exa.cortex_pb.WorkspaceInitializationData.data + */ + data = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.WorkspaceInitializationData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'workspace_type', + kind: 'enum', + T: proto3.getEnumType(WorkspaceType), + }, + { + no: 2, + name: 'git', + kind: 'message', + T: WorkspaceInitializationDataGit, + oneof: 'data', + }, + { + no: 3, + name: 'piper', + kind: 'message', + T: WorkspaceInitializationDataPiper, + oneof: 'data', + }, + ]); + static fromBinary(bytes, options) { + return new _WorkspaceInitializationData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WorkspaceInitializationData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WorkspaceInitializationData().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_WorkspaceInitializationData, a, b); + } +}; +var WorkspaceInitializationDataGit = class _WorkspaceInitializationDataGit extends Message { + /** + * @generated from field: exa.cortex_pb.CortexWorkspaceMetadata metadata = 1; + */ + metadata; + /** + * Commit hash between workspace and the default branch of the repository. + * + * @generated from field: string merge_base_commit_hash = 2; + */ + mergeBaseCommitHash = ''; + /** + * Patch between merge base and head commit. Will be nil if cleared or + * errored. Will be empty string if the diff is zero. + * + * @generated from field: optional string merge_base_head_patch_string = 3; + */ + mergeBaseHeadPatchString; + /** + * Patch between head commit and current working directory. + * + * @generated from field: optional string head_working_patch_string = 4; + */ + headWorkingPatchString; + /** + * Statistics about the workspace. May not be fully complete. + * + * @generated from field: exa.codeium_common_pb.WorkspaceStats workspace_stats = 5; + */ + workspaceStats; + /** + * Whether the repository is publicly accessible. + * + * @generated from field: bool repo_is_public = 6; + */ + repoIsPublic = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.WorkspaceInitializationDataGit'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'metadata', kind: 'message', T: CortexWorkspaceMetadata }, + { + no: 2, + name: 'merge_base_commit_hash', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'merge_base_head_patch_string', + kind: 'scalar', + T: 9, + opt: true, + }, + { + no: 4, + name: 'head_working_patch_string', + kind: 'scalar', + T: 9, + opt: true, + }, + { no: 5, name: 'workspace_stats', kind: 'message', T: WorkspaceStats }, + { + no: 6, + name: 'repo_is_public', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _WorkspaceInitializationDataGit().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WorkspaceInitializationDataGit().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WorkspaceInitializationDataGit().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_WorkspaceInitializationDataGit, a, b); + } +}; +var WorkspaceInitializationDataPiper = class _WorkspaceInitializationDataPiper extends Message { + /** + * @generated from field: string workspace_folder_absolute_uri = 1; + */ + workspaceFolderAbsoluteUri = ''; + /** + * @generated from field: int64 base_cl = 2 [deprecated = true]; + * @deprecated + */ + baseCl = protoInt64.zero; + /** + * @generated from oneof exa.cortex_pb.WorkspaceInitializationDataPiper.base_state + */ + baseState = { case: void 0 }; + /** + * @generated from field: repeated exa.cortex_pb.FileDiff file_diffs = 3; + */ + fileDiffs = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.WorkspaceInitializationDataPiper'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'workspace_folder_absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'base_cl', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 5, + name: 'base_changelist', + kind: 'scalar', + T: 3, + oneof: 'base_state', + }, + { + no: 4, + name: 'citc_snapshot_id', + kind: 'scalar', + T: 3, + oneof: 'base_state', + }, + { no: 3, name: 'file_diffs', kind: 'message', T: FileDiff, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _WorkspaceInitializationDataPiper().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WorkspaceInitializationDataPiper().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WorkspaceInitializationDataPiper().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_WorkspaceInitializationDataPiper, a, b); + } +}; +var FileDiff = class _FileDiff extends Message { + /** + * like //depot/google3/third_party/jetski/cortex_pb/cortex.proto + * see go/piper-api#depot_file_path + * + * @generated from field: string depot_path = 1; + */ + depotPath = ''; + /** + * @generated from oneof exa.cortex_pb.FileDiff.file_op + */ + fileOp = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FileDiff'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'depot_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'add', kind: 'message', T: FileDiffAdd, oneof: 'file_op' }, + { + no: 3, + name: 'remove', + kind: 'message', + T: FileDiffRemove, + oneof: 'file_op', + }, + { + no: 4, + name: 'modify', + kind: 'message', + T: FileDiffModify, + oneof: 'file_op', + }, + ]); + static fromBinary(bytes, options) { + return new _FileDiff().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileDiff().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileDiff().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FileDiff, a, b); + } +}; +var FileDiffAdd = class _FileDiffAdd extends Message { + /** + * @generated from field: string content = 1; + */ + content = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FileDiffAdd'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _FileDiffAdd().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileDiffAdd().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileDiffAdd().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FileDiffAdd, a, b); + } +}; +var FileDiffRemove = class _FileDiffRemove extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FileDiffRemove'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _FileDiffRemove().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileDiffRemove().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileDiffRemove().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FileDiffRemove, a, b); + } +}; +var FileDiffModify = class _FileDiffModify extends Message { + /** + * unified diff without header + * + * @generated from field: string diff = 1; + */ + diff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FileDiffModify'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _FileDiffModify().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileDiffModify().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileDiffModify().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FileDiffModify, a, b); + } +}; +var StateInitializationData = class _StateInitializationData extends Message { + /** + * Timestamp that the state initialization data corresponds to. + * + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp; + /** + * A unique id that represents this instance of state initialization data. + * Trajectories will be associated with this id. + * + * @generated from field: string state_id = 2; + */ + stateId = ''; + /** + * @generated from field: repeated exa.cortex_pb.WorkspaceInitializationData workspaces = 3; + */ + workspaces = []; + /** + * @generated from field: exa.cortex_pb.AritfactInitializationData artifacts = 4; + */ + artifacts; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.StateInitializationData'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'timestamp', kind: 'message', T: Timestamp }, + { + no: 2, + name: 'state_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'workspaces', + kind: 'message', + T: WorkspaceInitializationData, + repeated: true, + }, + { + no: 4, + name: 'artifacts', + kind: 'message', + T: AritfactInitializationData, + }, + ]); + static fromBinary(bytes, options) { + return new _StateInitializationData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StateInitializationData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StateInitializationData().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_StateInitializationData, a, b); + } +}; +var AritfactInitializationData = class _AritfactInitializationData extends Message { + /** + * Absolute URI to the artifact directory corresponding to this trajectory. + * + * @generated from field: string artifact_dir_uri = 1; + */ + artifactDirUri = ''; + /** + * Absolute URI to the base artifact directory for all trajectories. + * + * @generated from field: string artifact_base_dir_uri = 2; + */ + artifactBaseDirUri = ''; + /** + * Map from relative file path to LZ4 compressed file content. + * + * @generated from field: map compressed_artifact_files = 3; + */ + compressedArtifactFiles = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.AritfactInitializationData'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'artifact_dir_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'artifact_base_dir_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'compressed_artifact_files', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _AritfactInitializationData().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AritfactInitializationData().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AritfactInitializationData().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_AritfactInitializationData, a, b); + } +}; +var CortexWorkspaceMetadata = class _CortexWorkspaceMetadata extends Message { + /** + * @generated from field: string workspace_folder_absolute_uri = 1; + */ + workspaceFolderAbsoluteUri = ''; + /** + * @generated from field: string git_root_absolute_uri = 2; + */ + gitRootAbsoluteUri = ''; + /** + * @generated from field: exa.codeium_common_pb.Repository repository = 3; + */ + repository; + /** + * @generated from field: string branch_name = 4; + */ + branchName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexWorkspaceMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'workspace_folder_absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'git_root_absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'repository', kind: 'message', T: Repository }, + { + no: 4, + name: 'branch_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexWorkspaceMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexWorkspaceMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexWorkspaceMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexWorkspaceMetadata, a, b); + } +}; +var CortexTrajectoryMetadata = class _CortexTrajectoryMetadata extends Message { + /** + * @generated from field: repeated exa.cortex_pb.CortexWorkspaceMetadata workspaces = 1; + */ + workspaces = []; + /** + * @generated from field: google.protobuf.Timestamp created_at = 2; + */ + createdAt; + /** + * Corresponds to id of StateInitializationData + * + * @generated from field: string initialization_state_id = 3; + */ + initializationStateId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexTrajectoryMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'workspaces', + kind: 'message', + T: CortexWorkspaceMetadata, + repeated: true, + }, + { no: 2, name: 'created_at', kind: 'message', T: Timestamp }, + { + no: 3, + name: 'initialization_state_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexTrajectoryMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexTrajectoryMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexTrajectoryMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexTrajectoryMetadata, a, b); + } +}; +var CortexTrajectoryReference = class _CortexTrajectoryReference extends Message { + /** + * Id of the trajectory. + * + * @generated from field: string trajectory_id = 1; + */ + trajectoryId = ''; + /** + * Type of the referenced trajectory. + * + * @generated from field: exa.cortex_pb.CortexTrajectoryType trajectory_type = 3; + */ + trajectoryType = CortexTrajectoryType.UNSPECIFIED; + /** + * Index of a specific step in the trajectory (inclusive). + * For a pruning reference_type this means the FIRST step which is included in + * both parent and child + * + * 1 ----- 2 ----- 3 ----- 4 ----- 5 step_index = 3 + * 3 ----- 4 ----- 5 ----- 6' + * + * For a forking reference_type this means the LAST step which is included in + * both parent and child + * + * 1 ----- 2 ----- 3 ----- 4 ----- 5 step_index = 2 + * \ + * ----- 3`----- 4`----- 5`----- 6` + * + * + * @generated from field: int32 step_index = 2; + */ + stepIndex = 0; + /** + * Type of the step. + * + * @generated from field: exa.cortex_pb.CortexStepType step_type = 4; + */ + stepType = CortexStepType.UNSPECIFIED; + /** + * Reference type. + * + * @generated from field: exa.cortex_pb.CortexTrajectoryReferenceType reference_type = 5; + */ + referenceType = CortexTrajectoryReferenceType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexTrajectoryReference'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'trajectory_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'trajectory_type', + kind: 'enum', + T: proto3.getEnumType(CortexTrajectoryType), + }, + { + no: 2, + name: 'step_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'step_type', + kind: 'enum', + T: proto3.getEnumType(CortexStepType), + }, + { + no: 5, + name: 'reference_type', + kind: 'enum', + T: proto3.getEnumType(CortexTrajectoryReferenceType), + }, + ]); + static fromBinary(bytes, options) { + return new _CortexTrajectoryReference().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexTrajectoryReference().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexTrajectoryReference().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexTrajectoryReference, a, b); + } +}; +var ImplicitTrajectoryDescription = class _ImplicitTrajectoryDescription extends Message { + /** + * @generated from field: string trajectory_id = 1; + */ + trajectoryId = ''; + /** + * @generated from field: exa.cortex_pb.TrajectoryScope trajectory_scope = 2; + */ + trajectoryScope; + /** + * @generated from field: bool current = 3; + */ + current = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ImplicitTrajectoryDescription'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'trajectory_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'trajectory_scope', kind: 'message', T: TrajectoryScope }, + { + no: 3, + name: 'current', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ImplicitTrajectoryDescription().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ImplicitTrajectoryDescription().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ImplicitTrajectoryDescription().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ImplicitTrajectoryDescription, a, b); + } +}; +var InjectedResponseMetadata = class _InjectedResponseMetadata extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.InjectedResponseMetadata'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _InjectedResponseMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _InjectedResponseMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _InjectedResponseMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_InjectedResponseMetadata, a, b); + } +}; +var CortexStepGeneratorMetadata = class _CortexStepGeneratorMetadata extends Message { + /** + * @generated from field: repeated uint32 step_indices = 2; + */ + stepIndices = []; + /** + * @generated from oneof exa.cortex_pb.CortexStepGeneratorMetadata.metadata + */ + metadata = { case: void 0 }; + /** + * @generated from field: exa.cortex_pb.CascadePlannerConfig planner_config = 3; + */ + plannerConfig; + /** + * Id of the execution that this generator was run in. + * + * @generated from field: string execution_id = 4; + */ + executionId = ''; + /** + * If an error interrupted the generation, this is the error message. + * + * @generated from field: string error = 5; + */ + error = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepGeneratorMetadata'; + static fields = proto3.util.newFieldList(() => [ + { no: 2, name: 'step_indices', kind: 'scalar', T: 13, repeated: true }, + { + no: 1, + name: 'chat_model', + kind: 'message', + T: ChatModelMetadata, + oneof: 'metadata', + }, + { + no: 7, + name: 'injected', + kind: 'message', + T: InjectedResponseMetadata, + oneof: 'metadata', + }, + { no: 3, name: 'planner_config', kind: 'message', T: CascadePlannerConfig }, + { + no: 4, + name: 'execution_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepGeneratorMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepGeneratorMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepGeneratorMetadata().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepGeneratorMetadata, a, b); + } +}; +var MessagePromptMetadata = class _MessagePromptMetadata extends Message { + /** + * Index in the conversation. + * + * @generated from field: uint32 message_index = 1; + */ + messageIndex = 0; + /** + * In the nominal case, we make a request to the model with some messages: + * [Input1, Input2] And we receive some responses: [Output1, Output2]. The + * inputs will all have segment index 0, and responses will have segment + * index 1. In some cases, we may make repeated requests to the model in the + * same generator call, e.g in cases such as tool parse errors. For these, we + * will add additional inputs and outputs while incrementing the index in the + * same fashion. + * + * @generated from field: uint32 segment_index = 2; + */ + segmentIndex = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.MessagePromptMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'message_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'segment_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _MessagePromptMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MessagePromptMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MessagePromptMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_MessagePromptMetadata, a, b); + } +}; +var SectionJudgeCriteria = class _SectionJudgeCriteria extends Message { + /** + * Name of the section, will be ingested by a criteria judge as a metric name. + * + * @generated from field: string name = 1; + */ + name = ''; + /** + * Description of the criteria that the section should be evaluated against. + * + * @generated from field: string description = 2; + */ + description = ''; + /** + * An optional weighting for the weighted average calculation. If not provided + * then will use a simple average. + * + * @generated from field: optional uint32 weight = 3; + */ + weight; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.SectionJudgeCriteria'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'weight', kind: 'scalar', T: 13, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _SectionJudgeCriteria().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SectionJudgeCriteria().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SectionJudgeCriteria().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SectionJudgeCriteria, a, b); + } +}; +var PromptSectionMetadata = class _PromptSectionMetadata extends Message { + /** + * Source of the prompt content. + * + * @generated from field: exa.cortex_pb.PromptSectionMetadata.PromptSectionSourceType source_type = 1; + */ + sourceType = PromptSectionMetadata_PromptSectionSourceType.UNSPECIFIED; + /** + * Template key used to load the content. + * Only set when source_type = TEMPLATE. + * + * @generated from field: string template_key = 2; + */ + templateKey = ''; + /** + * Whether the template came from an internal source. + * Only set when source_type = TEMPLATE. + * + * @generated from field: bool is_internal = 3; + */ + isInternal = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.PromptSectionMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'source_type', + kind: 'enum', + T: proto3.getEnumType(PromptSectionMetadata_PromptSectionSourceType), + }, + { + no: 2, + name: 'template_key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'is_internal', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _PromptSectionMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptSectionMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptSectionMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PromptSectionMetadata, a, b); + } +}; +var PromptSectionMetadata_PromptSectionSourceType; +(function (PromptSectionMetadata_PromptSectionSourceType2) { + PromptSectionMetadata_PromptSectionSourceType2[ + (PromptSectionMetadata_PromptSectionSourceType2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + PromptSectionMetadata_PromptSectionSourceType2[ + (PromptSectionMetadata_PromptSectionSourceType2['RAW'] = 1) + ] = 'RAW'; + PromptSectionMetadata_PromptSectionSourceType2[ + (PromptSectionMetadata_PromptSectionSourceType2['TEMPLATE'] = 2) + ] = 'TEMPLATE'; +})( + PromptSectionMetadata_PromptSectionSourceType || + (PromptSectionMetadata_PromptSectionSourceType = {}), +); +proto3.util.setEnumType( + PromptSectionMetadata_PromptSectionSourceType, + 'exa.cortex_pb.PromptSectionMetadata.PromptSectionSourceType', + [ + { no: 0, name: 'PROMPT_SECTION_SOURCE_TYPE_UNSPECIFIED' }, + { no: 1, name: 'PROMPT_SECTION_SOURCE_TYPE_RAW' }, + { no: 2, name: 'PROMPT_SECTION_SOURCE_TYPE_TEMPLATE' }, + ], +); +var PromptSection = class _PromptSection extends Message { + /** + * @generated from field: string title = 1; + */ + title = ''; + /** + * @generated from field: string content = 2; + */ + content = ''; + /** + * @generated from field: repeated exa.cortex_pb.SectionJudgeCriteria criteria = 3; + */ + criteria = []; + /** + * Metadata about where the content came from. + * + * @generated from field: exa.cortex_pb.PromptSectionMetadata metadata = 4; + */ + metadata; + /** + * Dynamic content that varies per user/session, inserted as chat messages. + * This is kept separate from 'content' to maximize prefix caching. + * + * @generated from field: string dynamic_content = 5; + */ + dynamicContent = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.PromptSection'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'criteria', + kind: 'message', + T: SectionJudgeCriteria, + repeated: true, + }, + { no: 4, name: 'metadata', kind: 'message', T: PromptSectionMetadata }, + { + no: 5, + name: 'dynamic_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _PromptSection().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptSection().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptSection().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PromptSection, a, b); + } +}; +var RetryInfo = class _RetryInfo extends Message { + /** + * Sherlog link for this retry attempt + * + * @generated from field: string sherlog_link = 1; + */ + sherlogLink = ''; + /** + * Model usage stats for this retry attempt. + * + * @generated from field: exa.codeium_common_pb.ModelUsageStats usage = 2; + */ + usage; + /** + * Error message (empty if no error) for this retry attempt. + * + * @generated from field: string error = 3; + */ + error = ''; + /** + * Trace ID for this retry attempt. + * + * @generated from field: string trace_id = 4; + */ + traceId = ''; + /** + * Categorizes the reason for this retry. + * + * @generated from field: exa.cortex_pb.RetryReason retry_reason = 5; + */ + retryReason = RetryReason.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.RetryInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'sherlog_link', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'usage', kind: 'message', T: ModelUsageStats }, + { + no: 3, + name: 'error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'trace_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'retry_reason', + kind: 'enum', + T: proto3.getEnumType(RetryReason), + }, + ]); + static fromBinary(bytes, options) { + return new _RetryInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RetryInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RetryInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RetryInfo, a, b); + } +}; +var ChatModelMetadata = class _ChatModelMetadata extends Message { + /** + * @generated from field: string system_prompt = 1; + */ + systemPrompt = ''; + /** + * @generated from field: repeated exa.chat_pb.ChatMessagePrompt message_prompts = 2; + */ + messagePrompts = []; + /** + * Corresponds index-wise to message prompts. + * + * @generated from field: repeated exa.cortex_pb.MessagePromptMetadata message_metadata = 10; + */ + messageMetadata = []; + /** + * @generated from field: exa.codeium_common_pb.Model model = 3; + */ + model = Model.UNSPECIFIED; + /** + * @generated from field: exa.codeium_common_pb.ModelUsageStats usage = 4; + */ + usage; + /** + * @generated from field: float model_cost = 5; + */ + modelCost = 0; + /** + * The latest message index in this conversation that wrote to cache. + * + * @generated from field: uint32 last_cache_index = 6; + */ + lastCacheIndex = 0; + /** + * @generated from field: exa.chat_pb.ChatToolChoice tool_choice = 7; + */ + toolChoice; + /** + * @generated from field: repeated exa.chat_pb.ChatToolDefinition tools = 8; + */ + tools = []; + /** + * @generated from field: exa.cortex_pb.ChatStartMetadata chat_start_metadata = 9; + */ + chatStartMetadata; + /** + * @generated from field: google.protobuf.Duration time_to_first_token = 11; + */ + timeToFirstToken; + /** + * @generated from field: google.protobuf.Duration streaming_duration = 12; + */ + streamingDuration; + /** + * Some models use API pricing instead of fixed usage pricing. If that is the + * case, then this field will be populated with the converted API pricing cost + * that is based on the exact usage in the request. + * + * @generated from field: int32 credit_cost = 13; + */ + creditCost = 0; + /** + * Number of retries in this generator loop + * + * @generated from field: uint32 retries = 14; + */ + retries = 0; + /** + * Completion configuration used to generate the model request + * + * @generated from field: exa.codeium_common_pb.CompletionConfiguration completion_config = 15; + */ + completionConfig; + /** + * Structured prompt sections that make up the system prompt + * + * @generated from field: repeated exa.cortex_pb.PromptSection prompt_sections = 16; + */ + promptSections = []; + /** + * Per-retry information, one entry for each retry attempt. + * + * @generated from field: repeated exa.cortex_pb.RetryInfo retry_infos = 17; + */ + retryInfos = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ChatModelMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'system_prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'message_prompts', + kind: 'message', + T: ChatMessagePrompt, + repeated: true, + }, + { + no: 10, + name: 'message_metadata', + kind: 'message', + T: MessagePromptMetadata, + repeated: true, + }, + { no: 3, name: 'model', kind: 'enum', T: proto3.getEnumType(Model) }, + { no: 4, name: 'usage', kind: 'message', T: ModelUsageStats }, + { + no: 5, + name: 'model_cost', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 6, + name: 'last_cache_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 7, name: 'tool_choice', kind: 'message', T: ChatToolChoice }, + { + no: 8, + name: 'tools', + kind: 'message', + T: ChatToolDefinition, + repeated: true, + }, + { + no: 9, + name: 'chat_start_metadata', + kind: 'message', + T: ChatStartMetadata, + }, + { no: 11, name: 'time_to_first_token', kind: 'message', T: Duration }, + { no: 12, name: 'streaming_duration', kind: 'message', T: Duration }, + { + no: 13, + name: 'credit_cost', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 14, + name: 'retries', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 15, + name: 'completion_config', + kind: 'message', + T: CompletionConfiguration, + }, + { + no: 16, + name: 'prompt_sections', + kind: 'message', + T: PromptSection, + repeated: true, + }, + { + no: 17, + name: 'retry_infos', + kind: 'message', + T: RetryInfo, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ChatModelMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatModelMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatModelMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatModelMetadata, a, b); + } +}; +var ContextWindowMetadata = class _ContextWindowMetadata extends Message { + /** + * Estimated number of tokens consumed in the current generator request + * This count is used to make context window truncation decisions and + * will differ from the actual model usage stats due to imprecise tokenizers + * and decisions of what to count in the context window. + * + * @generated from field: int32 estimated_tokens_used = 1; + */ + estimatedTokensUsed = 0; + /** + * The reason why a truncation event occurred during this invocation, if any + * + * @generated from field: exa.cortex_pb.TruncationReason truncation_reason = 2; + */ + truncationReason = TruncationReason.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ContextWindowMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'estimated_tokens_used', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'truncation_reason', + kind: 'enum', + T: proto3.getEnumType(TruncationReason), + }, + ]); + static fromBinary(bytes, options) { + return new _ContextWindowMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ContextWindowMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ContextWindowMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ContextWindowMetadata, a, b); + } +}; +var CacheBreakpointMetadata = class _CacheBreakpointMetadata extends Message { + /** + * @generated from field: uint32 index = 1; + */ + index = 0; + /** + * @generated from field: exa.chat_pb.PromptCacheOptions options = 2; + */ + options; + /** + * Checksum of the chat prompts from the beginning of conversation until this + * breakpoint. + * + * @generated from field: string content_checksum = 3; + */ + contentChecksum = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CacheBreakpointMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 2, name: 'options', kind: 'message', T: PromptCacheOptions }, + { + no: 3, + name: 'content_checksum', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CacheBreakpointMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CacheBreakpointMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CacheBreakpointMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CacheBreakpointMetadata, a, b); + } +}; +var ChatStartMetadata = class _ChatStartMetadata extends Message { + /** + * Timestamp representing when the conversation started. This is before stream + * creation. + * + * @generated from field: google.protobuf.Timestamp created_at = 4; + */ + createdAt; + /** + * The trajectory step index where the conversation begins. + * + * @generated from field: uint32 start_step_index = 1; + */ + startStepIndex = 0; + /** + * The checkpoint index used to start the conversation. If -1, then no + * checkpoint was used. + * + * @generated from field: int32 checkpoint_index = 2; + */ + checkpointIndex = 0; + /** + * The trajectory step indices that were covered by the checkpoint. + * + * @generated from field: repeated uint32 steps_covered_by_checkpoint = 3; + */ + stepsCoveredByCheckpoint = []; + /** + * The index of the latest stable message in the generated chat prompts. A + * message is considered stable if the string-conversion of the step it was + * converted from is guaranteed to not change in the future. -1 denotes that + * there is no stable message. + * + * @generated from field: int32 latest_stable_message_index = 5; + */ + latestStableMessageIndex = 0; + /** + * Metadata regarding where cache breakpoints are set in the chat request. + * + * @generated from field: repeated exa.cortex_pb.CacheBreakpointMetadata cache_breakpoints = 6; + */ + cacheBreakpoints = []; + /** + * Metadata regarding the system prompt cache breakpoint. + * + * @generated from field: exa.cortex_pb.CacheBreakpointMetadata system_prompt_cache = 7; + */ + systemPromptCache; + /** + * Time since the last chat request. + * + * @generated from field: google.protobuf.Duration time_since_last_invocation = 8; + */ + timeSinceLastInvocation; + /** + * Request for how caching should be handled for this chat request. Ignored if + * nil. + * TODO(matt): Switch consumers to populate this instead. + * + * @generated from field: exa.cortex_pb.CacheRequestOptions cache_request = 9; + */ + cacheRequest; + /** + * Metadata about the context window used in the current generator request + * + * @generated from field: exa.cortex_pb.ContextWindowMetadata context_window_metadata = 10; + */ + contextWindowMetadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ChatStartMetadata'; + static fields = proto3.util.newFieldList(() => [ + { no: 4, name: 'created_at', kind: 'message', T: Timestamp }, + { + no: 1, + name: 'start_step_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'checkpoint_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'steps_covered_by_checkpoint', + kind: 'scalar', + T: 13, + repeated: true, + }, + { + no: 5, + name: 'latest_stable_message_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'cache_breakpoints', + kind: 'message', + T: CacheBreakpointMetadata, + repeated: true, + }, + { + no: 7, + name: 'system_prompt_cache', + kind: 'message', + T: CacheBreakpointMetadata, + }, + { no: 8, name: 'time_since_last_invocation', kind: 'message', T: Duration }, + { no: 9, name: 'cache_request', kind: 'message', T: CacheRequestOptions }, + { + no: 10, + name: 'context_window_metadata', + kind: 'message', + T: ContextWindowMetadata, + }, + ]); + static fromBinary(bytes, options) { + return new _ChatStartMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ChatStartMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ChatStartMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ChatStartMetadata, a, b); + } +}; +var CacheRequestOptions = class _CacheRequestOptions extends Message { + /** + * Whether to enable caching. All other fields are ignored if this is false. + * + * @generated from field: bool enabled = 1; + */ + enabled = false; + /** + * Indices of breakpoints to set in the request. Corresponds to indices in the + * request chat messages. + * + * TODO(matt): Add more options here, e.g toggling if system prompt is cached, + * and also if we set cache breakpoints relative to the previous message. + * + * @generated from field: repeated uint32 cache_breakpoint_indices = 2; + */ + cacheBreakpointIndices = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CacheRequestOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'enabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'cache_breakpoint_indices', + kind: 'scalar', + T: 13, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CacheRequestOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CacheRequestOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CacheRequestOptions().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CacheRequestOptions, a, b); + } +}; +var SnapshotMetadata = class _SnapshotMetadata extends Message { + /** + * TODO(saujas): Make this a oneof with CitC metadata just being one variant. + * + * @generated from field: string user = 1; + */ + user = ''; + /** + * @generated from field: string workspace_id = 2; + */ + workspaceId = ''; + /** + * @generated from field: uint32 snapshot_version = 3; + */ + snapshotVersion = 0; + /** + * @generated from field: exa.cortex_pb.WorkspaceType workspace_type = 4; + */ + workspaceType = WorkspaceType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.SnapshotMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'user', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'workspace_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'snapshot_version', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'workspace_type', + kind: 'enum', + T: proto3.getEnumType(WorkspaceType), + }, + ]); + static fromBinary(bytes, options) { + return new _SnapshotMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SnapshotMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SnapshotMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SnapshotMetadata, a, b); + } +}; +var StatusTransition = class _StatusTransition extends Message { + /** + * @generated from field: exa.cortex_pb.CortexStepStatus updated_status = 1; + */ + updatedStatus = CortexStepStatus.UNSPECIFIED; + /** + * @generated from field: google.protobuf.Timestamp timestamp = 2; + */ + timestamp; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.StatusTransition'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'updated_status', + kind: 'enum', + T: proto3.getEnumType(CortexStepStatus), + }, + { no: 2, name: 'timestamp', kind: 'message', T: Timestamp }, + ]); + static fromBinary(bytes, options) { + return new _StatusTransition().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StatusTransition().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StatusTransition().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_StatusTransition, a, b); + } +}; +var CortexStepInternalMetadata = class _CortexStepInternalMetadata extends Message { + /** + * @generated from field: repeated exa.cortex_pb.StatusTransition status_transitions = 1; + */ + statusTransitions = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepInternalMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'status_transitions', + kind: 'message', + T: StatusTransition, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepInternalMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepInternalMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepInternalMetadata().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepInternalMetadata, a, b); + } +}; +var CortexStepMetadata = class _CortexStepMetadata extends Message { + /** + * Version of the step generation logic that was used to generate this step. + * This can be used to make compatibility checks between different versions of + * the step generation logic in case there are breaking changes. + * + * @generated from field: uint32 step_generation_version = 21; + */ + stepGenerationVersion = 0; + /** + * Timestamp when the step was created. + * - Planner response: post stream creation, pre first response. + * - Tool call: first tool call chunk from stream. + * - User input: when the user sends (even if queued). + * + * @generated from field: google.protobuf.Timestamp created_at = 1; + */ + createdAt; + /** + * Timestamp when the step was first viewable by the user. + * - Planner response: first text chunk from stream. + * - Tool call: all prioritized arguments received. + * + * @generated from field: google.protobuf.Timestamp viewable_at = 6; + */ + viewableAt; + /** + * Timestamp when the step was finished generating. + * - Planner response: end of planner text chunks. + * - Tool call: end of tool call chunks. + * + * @generated from field: google.protobuf.Timestamp finished_generating_at = 7; + */ + finishedGeneratingAt; + /** + * Timestamp when the last chunk was completed. + * - Planner response: N/A + * - Tool call: end of each tool call chunk (code edits). + * + * @generated from field: google.protobuf.Timestamp last_completed_chunk_at = 22; + */ + lastCompletedChunkAt; + /** + * Timestamp when the step was completed (including tool execution for tool + * calls). + * - Planner response: same as finished_generating_at. + * - Tool call: end of tool execution. + * + * @generated from field: google.protobuf.Timestamp completed_at = 8; + */ + completedAt; + /** + * Step was added because of something done by this source. + * + * @generated from field: exa.cortex_pb.CortexStepSource source = 3; + */ + source = CortexStepSource.UNSPECIFIED; + /** + * Only populated if step is created by a model with tool-calling capability. + * + * @generated from field: exa.codeium_common_pb.ChatToolCall tool_call = 4; + */ + toolCall; + /** + * Order in which arguments were generated by the model. + * + * @generated from field: repeated string arguments_order = 5; + */ + argumentsOrder = []; + /** + * Only populated if step handling itself makes use of a model, eg. checkpoint + * generation. + * + * @generated from field: exa.codeium_common_pb.ModelUsageStats model_usage = 9; + */ + modelUsage; + /** + * @generated from field: repeated exa.cortex_pb.RetryInfo retry_infos = 28; + */ + retryInfos = []; + /** + * @generated from field: float model_cost = 10; + */ + modelCost = 0; + /** + * Info about the model that created this step, if any. + * + * @generated from field: exa.codeium_common_pb.Model generator_model = 11; + */ + generatorModel = Model.UNSPECIFIED; + /** + * @generated from field: exa.codeium_common_pb.ModelOrAlias requested_model = 13; + */ + requestedModel; + /** + * Model info of the custom model used. Only populated if the step was created + * by a custom model, aka the generator_model is + * MODEL_GOOGLE_GEMINI_INTERNAL_BYOM. + * + * @generated from field: exa.codeium_common_pb.ModelInfo model_info = 24; + */ + modelInfo; + /** + * Id of the execution invocation that created this step. + * + * @generated from field: string execution_id = 12; + */ + executionId = ''; + /** + * The realized flow credit cost of the step, factoring step type and status + * and more. The value is 100x of a user-interpreted credit, i.e a standard + * single credit is 100. DEPRECATED: Flow credits aren't used anymore. + * + * @generated from field: int32 flow_credits_used = 14 [deprecated = true]; + * @deprecated + */ + flowCreditsUsed = 0; + /** + * The realized prompt credit cost of the step, only applicable to user input + * steps. This value is also 100x. + * + * @generated from field: int32 prompt_credits_used = 15; + */ + promptCreditsUsed = 0; + /** + * Reasons why the step used a non-standard amount of credits. Generically, + * this should be empty to indicate no reason beyond standard pricing + * considerations. DEPRECATED: Non-standard credit reasons aren't used + * anymore. + * + * @generated from field: repeated exa.cortex_pb.CortexStepCreditReason non_standard_credit_reasons = 18 [deprecated = true]; + * @deprecated + */ + nonStandardCreditReasons = []; + /** + * These are for the subagent that chooses between multiple tool-call options + * + * @generated from field: repeated exa.codeium_common_pb.ChatToolCall tool_call_choices = 16; + */ + toolCallChoices = []; + /** + * @generated from field: string tool_call_choice_reason = 17; + */ + toolCallChoiceReason = ''; + /** + * Request source that led to this step + * + * @generated from field: exa.cortex_pb.CortexRequestSource cortex_request_source = 19; + */ + cortexRequestSource = CortexRequestSource.UNSPECIFIED; + /** + * Number of output tokens generated so far in streaming responses. + * Only populated for tool calls. + * + * @generated from field: int32 tool_call_output_tokens = 23; + */ + toolCallOutputTokens = 0; + /** + * Info about the source trajectory this step is from. + * We expect this to be populated for all steps. This info should uniquely + * identify a step, and should be used as the source of truth for + * trajectory ID and step index where such specifiers are required. + * + * @generated from field: exa.cortex_pb.SourceTrajectoryStepInfo source_trajectory_step_info = 20; + */ + sourceTrajectoryStepInfo; + /** + * Metadata about the snapshot at the start of this step. + * A snapshot is some unique identifier of the filesystem and/or process + * state, which can be used to recover the state when this trajectory step was + * generated. + * + * @generated from field: exa.cortex_pb.SnapshotMetadata snapshot_metadata = 25; + */ + snapshotMetadata; + /** + * Internal metadata managed exclusively by TrajectoryWrapper. + * TrajectoryWrapper users cannot modify this field when updating steps. + * This avoids stale data issues that can arise when calling + * TrajectoryWrapper.UpdateStep since the passed in step object is not + * updated in the function. + * + * @generated from field: exa.cortex_pb.CortexStepInternalMetadata internal_metadata = 26; + */ + internalMetadata; + /** + * If true, this step should wait for previous tool call steps from the same + * model invocation to complete before executing. If false or unset, this step + * should execute immediately without waiting for previous steps. + * + * @generated from field: bool wait_for_previous_tools = 27; + */ + waitForPreviousTools = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 21, + name: 'step_generation_version', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 1, name: 'created_at', kind: 'message', T: Timestamp }, + { no: 6, name: 'viewable_at', kind: 'message', T: Timestamp }, + { no: 7, name: 'finished_generating_at', kind: 'message', T: Timestamp }, + { no: 22, name: 'last_completed_chunk_at', kind: 'message', T: Timestamp }, + { no: 8, name: 'completed_at', kind: 'message', T: Timestamp }, + { + no: 3, + name: 'source', + kind: 'enum', + T: proto3.getEnumType(CortexStepSource), + }, + { no: 4, name: 'tool_call', kind: 'message', T: ChatToolCall }, + { no: 5, name: 'arguments_order', kind: 'scalar', T: 9, repeated: true }, + { no: 9, name: 'model_usage', kind: 'message', T: ModelUsageStats }, + { + no: 28, + name: 'retry_infos', + kind: 'message', + T: RetryInfo, + repeated: true, + }, + { + no: 10, + name: 'model_cost', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 11, + name: 'generator_model', + kind: 'enum', + T: proto3.getEnumType(Model), + }, + { no: 13, name: 'requested_model', kind: 'message', T: ModelOrAlias }, + { no: 24, name: 'model_info', kind: 'message', T: ModelInfo }, + { + no: 12, + name: 'execution_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 14, + name: 'flow_credits_used', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 15, + name: 'prompt_credits_used', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 18, + name: 'non_standard_credit_reasons', + kind: 'enum', + T: proto3.getEnumType(CortexStepCreditReason), + repeated: true, + }, + { + no: 16, + name: 'tool_call_choices', + kind: 'message', + T: ChatToolCall, + repeated: true, + }, + { + no: 17, + name: 'tool_call_choice_reason', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 19, + name: 'cortex_request_source', + kind: 'enum', + T: proto3.getEnumType(CortexRequestSource), + }, + { + no: 23, + name: 'tool_call_output_tokens', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 20, + name: 'source_trajectory_step_info', + kind: 'message', + T: SourceTrajectoryStepInfo, + }, + { no: 25, name: 'snapshot_metadata', kind: 'message', T: SnapshotMetadata }, + { + no: 26, + name: 'internal_metadata', + kind: 'message', + T: CortexStepInternalMetadata, + }, + { + no: 27, + name: 'wait_for_previous_tools', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepMetadata, a, b); + } +}; +var FileAccessPermission = class _FileAccessPermission extends Message { + /** + * @generated from field: string path = 1; + */ + path = ''; + /** + * @generated from field: bool is_directory = 2; + */ + isDirectory = false; + /** + * @generated from field: bool allow = 3; + */ + allow = false; + /** + * @generated from field: exa.cortex_pb.PermissionScope scope = 4; + */ + scope = PermissionScope.UNSPECIFIED; + /** + * Permission was explicitly set by the user this step. + * + * @generated from field: bool from_current_step = 5; + */ + fromCurrentStep = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FileAccessPermission'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'is_directory', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'allow', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'scope', + kind: 'enum', + T: proto3.getEnumType(PermissionScope), + }, + { + no: 5, + name: 'from_current_step', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _FileAccessPermission().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FileAccessPermission().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FileAccessPermission().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FileAccessPermission, a, b); + } +}; +var TrajectoryPermissions = class _TrajectoryPermissions extends Message { + /** + * All file access permissions (both granted and denied). + * Filter by the 'allow' field to distinguish grants from denials. + * Filter by 'scope' field to distinguish persistent vs temporary. + * + * @generated from field: repeated exa.cortex_pb.FileAccessPermission file_access_permissions = 1; + */ + fileAccessPermissions = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TrajectoryPermissions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'file_access_permissions', + kind: 'message', + T: FileAccessPermission, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _TrajectoryPermissions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TrajectoryPermissions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TrajectoryPermissions().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TrajectoryPermissions, a, b); + } +}; +var SourceTrajectoryStepInfo = class _SourceTrajectoryStepInfo extends Message { + /** + * ID of source trajectory + * + * @generated from field: string trajectory_id = 1; + */ + trajectoryId = ''; + /** + * Step index in source trajectory + * + * @generated from field: uint32 step_index = 2; + */ + stepIndex = 0; + /** + * Generator metadata index in source trajectory (if applicable) + * + * @generated from field: uint32 metadata_index = 3; + */ + metadataIndex = 0; + /** + * Cascade ID of source trajectory (if applicable) + * + * @generated from field: string cascade_id = 4; + */ + cascadeId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.SourceTrajectoryStepInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'trajectory_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'step_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'metadata_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'cascade_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _SourceTrajectoryStepInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SourceTrajectoryStepInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SourceTrajectoryStepInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SourceTrajectoryStepInfo, a, b); + } +}; +var StructuredErrorPart = class _StructuredErrorPart extends Message { + /** + * @generated from oneof exa.cortex_pb.StructuredErrorPart.part + */ + part = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.StructuredErrorPart'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'text', kind: 'scalar', T: 9, oneof: 'part' }, + { no: 2, name: 'file_uri', kind: 'scalar', T: 9, oneof: 'part' }, + { no: 3, name: 'directory_uri', kind: 'scalar', T: 9, oneof: 'part' }, + { no: 4, name: 'url', kind: 'scalar', T: 9, oneof: 'part' }, + { no: 5, name: 'code_text', kind: 'scalar', T: 9, oneof: 'part' }, + ]); + static fromBinary(bytes, options) { + return new _StructuredErrorPart().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StructuredErrorPart().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StructuredErrorPart().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_StructuredErrorPart, a, b); + } +}; +var CortexErrorDetails = class _CortexErrorDetails extends Message { + /** + * Error message which may be read by an end user. Leave blank if this error + * should not be viewed by the user at all. + * + * @generated from field: string user_error_message = 1; + */ + userErrorMessage = ''; + /** + * Error message which will be shown to the model. If this is empty, then + * the short_error will be shown to the model. + * + * @generated from field: string model_error_message = 9; + */ + modelErrorMessage = ''; + /** + * Structured error parts for user rendering. + * + * @generated from field: repeated exa.cortex_pb.StructuredErrorPart structured_error_parts = 8; + */ + structuredErrorParts = []; + /** + * Corresponds to err.Error(). + * + * @generated from field: string short_error = 2; + */ + shortError = ''; + /** + * Corresponds to the "%+v" format specifier on an error. + * + * @generated from field: string full_error = 3; + */ + fullError = ''; + /** + * True if the error is benign and should not be presented as an "error" to + * the user. + * + * @generated from field: bool is_benign = 4; + */ + isBenign = false; + /** + * Only populated for a subset of errors. + * + * @generated from field: uint32 error_code = 7; + */ + errorCode = 0; + /** + * Additional details about the error. + * + * @generated from field: string details = 5; + */ + details = ''; + /** + * Stores the Sentry event ID. + * + * @generated from field: string error_id = 6; + */ + errorId = ''; + /** + * Structured error details from the API response (e.g., DebugInfo, + * RetryInfo). Each string is the JSON-serialized form of a detail from + * `google.rpc.Status.details`. + * + * @generated from field: repeated string rpc_error_details = 10; + */ + rpcErrorDetails = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexErrorDetails'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'user_error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'model_error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'structured_error_parts', + kind: 'message', + T: StructuredErrorPart, + repeated: true, + }, + { + no: 2, + name: 'short_error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'full_error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'is_benign', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'error_code', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'details', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'error_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 10, name: 'rpc_error_details', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _CortexErrorDetails().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexErrorDetails().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexErrorDetails().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexErrorDetails, a, b); + } +}; +var UserStepSnapshot = class _UserStepSnapshot extends Message { + /** + * @generated from field: string name = 1; + */ + name = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.UserStepSnapshot'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _UserStepSnapshot().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserStepSnapshot().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserStepSnapshot().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserStepSnapshot, a, b); + } +}; +var UserStepAnnotations = class _UserStepAnnotations extends Message { + /** + * @generated from field: exa.cortex_pb.UserStepSnapshot snapshot = 1; + */ + snapshot; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.UserStepAnnotations'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'snapshot', kind: 'message', T: UserStepSnapshot }, + ]); + static fromBinary(bytes, options) { + return new _UserStepAnnotations().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserStepAnnotations().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserStepAnnotations().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_UserStepAnnotations, a, b); + } +}; +var TrajectoryScope = class _TrajectoryScope extends Message { + /** + * @generated from field: string workspace_uri = 1; + */ + workspaceUri = ''; + /** + * @generated from field: string git_root_uri = 2; + */ + gitRootUri = ''; + /** + * @generated from field: string branch_name = 3; + */ + branchName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TrajectoryScope'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'workspace_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'git_root_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'branch_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _TrajectoryScope().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TrajectoryScope().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TrajectoryScope().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TrajectoryScope, a, b); + } +}; +var CascadeExecutorConfig = class _CascadeExecutorConfig extends Message { + /** + * @generated from field: optional bool disable_async = 1; + */ + disableAsync; + /** + * @generated from field: int32 max_generator_invocations = 2; + */ + maxGeneratorInvocations = 0; + /** + * @generated from field: repeated exa.cortex_pb.CortexStepType terminal_step_types = 3; + */ + terminalStepTypes = []; + /** + * If true, the executor will block until either a valid checkpoint is + * available or all checkpoints are ERRORed out + * + * @generated from field: optional bool hold_for_valid_checkpoint = 5; + */ + holdForValidCheckpoint; + /** + * How long to wait for a valid checkpoint state before continuing without a + * checkpoint + * + * @generated from field: int32 hold_for_valid_checkpoint_timeout = 6; + */ + holdForValidCheckpointTimeout = 0; + /** + * If true, the executor will not execute any non-research steps + * + * @generated from field: bool research_only = 7; + */ + researchOnly = false; + /** + * If true, the executor will use aggressive snapshotting (snapshot before + * cascade execution) If this is on, any edits that are made by cascade will + * also be reported as edits made by the user (which is fine in read-only mode + * when cascade is not making edits). + * + * @generated from field: optional bool use_aggressive_snapshotting = 8; + */ + useAggressiveSnapshotting; + /** + * If true, the executor will only terminate when the finish tool has been + * called. If the model responds with no tool call, then the executor will + * force another invocation with a user message to continue, up to + * max_forced_invocations times. + * + * @generated from field: optional bool require_finish_tool = 9; + */ + requireFinishTool; + /** + * Maximum number of times the executor will force an invocation, if the + * model has not called a tool. This is only used if require_finish_tool is + * true. + * + * @generated from field: optional int32 max_forced_invocations = 10; + */ + maxForcedInvocations; + /** + * If true, the executor will queue all steps (no concurrency) + * + * @generated from field: optional bool queue_all_steps = 11; + */ + queueAllSteps; + /** + * If true, the executor will store the GenerateContentRequest proto in the + * ExecutorMetadata. This is used by training/evaluation pipelines to + * reconstruct the model request. + * + * @generated from field: optional bool store_gen_svc_request = 12; + */ + storeGenSvcRequest; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeExecutorConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'disable_async', kind: 'scalar', T: 8, opt: true }, + { + no: 2, + name: 'max_generator_invocations', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'terminal_step_types', + kind: 'enum', + T: proto3.getEnumType(CortexStepType), + repeated: true, + }, + { + no: 5, + name: 'hold_for_valid_checkpoint', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 6, + name: 'hold_for_valid_checkpoint_timeout', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 7, + name: 'research_only', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 8, + name: 'use_aggressive_snapshotting', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 9, name: 'require_finish_tool', kind: 'scalar', T: 8, opt: true }, + { no: 10, name: 'max_forced_invocations', kind: 'scalar', T: 5, opt: true }, + { no: 11, name: 'queue_all_steps', kind: 'scalar', T: 8, opt: true }, + { no: 12, name: 'store_gen_svc_request', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _CascadeExecutorConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeExecutorConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeExecutorConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadeExecutorConfig, a, b); + } +}; +var ForcedBrainUpdateConfig = class _ForcedBrainUpdateConfig extends Message { + /** + * Controls how often the update strategy is applied. For example, if set to + * 0.25, the update strategy will be applied about a quarter of the time. + * + * @generated from field: optional float update_sample_rate = 1; + */ + updateSampleRate; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ForcedBrainUpdateConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'update_sample_rate', kind: 'scalar', T: 2, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _ForcedBrainUpdateConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ForcedBrainUpdateConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ForcedBrainUpdateConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ForcedBrainUpdateConfig, a, b); + } +}; +var DynamicBrainUpdateConfig = class _DynamicBrainUpdateConfig extends Message { + /** + * If true, uses a more aggressive ephemeral prompt (for internal models that + * otherwise will not call the plan tool) + * + * @generated from field: bool use_aggressive_prompt = 1; + */ + useAggressivePrompt = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.DynamicBrainUpdateConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'use_aggressive_prompt', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _DynamicBrainUpdateConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DynamicBrainUpdateConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DynamicBrainUpdateConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DynamicBrainUpdateConfig, a, b); + } +}; +var BrainUpdateStrategy = class _BrainUpdateStrategy extends Message { + /** + * @generated from oneof exa.cortex_pb.BrainUpdateStrategy.strategy + */ + strategy = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrainUpdateStrategy'; + static fields = proto3.util.newFieldList(() => [ + { + no: 2, + name: 'executor_forced', + kind: 'message', + T: Empty, + oneof: 'strategy', + }, + { + no: 3, + name: 'invocation_forced', + kind: 'message', + T: ForcedBrainUpdateConfig, + oneof: 'strategy', + }, + { + no: 6, + name: 'dynamic_update', + kind: 'message', + T: DynamicBrainUpdateConfig, + oneof: 'strategy', + }, + { + no: 5, + name: 'executor_forced_and_with_discretion', + kind: 'message', + T: Empty, + oneof: 'strategy', + }, + ]); + static fromBinary(bytes, options) { + return new _BrainUpdateStrategy().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrainUpdateStrategy().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrainUpdateStrategy().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrainUpdateStrategy, a, b); + } +}; +var LogArtifactsConfig = class _LogArtifactsConfig extends Message { + /** + * @generated from field: optional bool enabled = 1; + */ + enabled; + /** + * If true, only model steps and user input steps are included in the + * conversation logs + * + * @generated from field: optional bool hide_nominal_tool_steps = 2; + */ + hideNominalToolSteps; + /** + * If true, planner response text is hidden in the conversation logs + * Tool calls will continue to be rendered + * + * @generated from field: optional bool hide_planner_response_text = 3; + */ + hidePlannerResponseText; + /** + * Step outputs beyond max_bytes_per_step will be truncated + * + * @generated from field: int32 max_bytes_per_step = 4; + */ + maxBytesPerStep = 0; + /** + * Tool arguments beyond max_bytes_per_tool_arg will be truncated + * + * @generated from field: int32 max_bytes_per_tool_arg = 5; + */ + maxBytesPerToolArg = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.LogArtifactsConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { no: 2, name: 'hide_nominal_tool_steps', kind: 'scalar', T: 8, opt: true }, + { + no: 3, + name: 'hide_planner_response_text', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 4, + name: 'max_bytes_per_step', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'max_bytes_per_tool_arg', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _LogArtifactsConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LogArtifactsConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LogArtifactsConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LogArtifactsConfig, a, b); + } +}; +var CascadeConfig = class _CascadeConfig extends Message { + /** + * @generated from field: exa.cortex_pb.CascadePlannerConfig planner_config = 1; + */ + plannerConfig; + /** + * TODO(nmoy): remove checkpoint config and make it a field of + * TrajectoryConversionConfig. + * + * @generated from field: exa.cortex_pb.CheckpointConfig checkpoint_config = 2; + */ + checkpointConfig; + /** + * @generated from field: exa.cortex_pb.CascadeExecutorConfig executor_config = 3; + */ + executorConfig; + /** + * @generated from field: exa.cortex_pb.TrajectoryConversionConfig trajectory_conversion_config = 4; + */ + trajectoryConversionConfig; + /** + * If true, applies model-specific configs when building the default config + * + * @generated from field: optional bool apply_model_default_override = 6; + */ + applyModelDefaultOverride; + /** + * @generated from field: exa.cortex_pb.ConversationHistoryConfig conversation_history_config = 7; + */ + conversationHistoryConfig; + /** + * @generated from field: optional bool split_dynamic_prompt_sections = 8; + */ + splitDynamicPromptSections; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'planner_config', kind: 'message', T: CascadePlannerConfig }, + { no: 2, name: 'checkpoint_config', kind: 'message', T: CheckpointConfig }, + { + no: 3, + name: 'executor_config', + kind: 'message', + T: CascadeExecutorConfig, + }, + { + no: 4, + name: 'trajectory_conversion_config', + kind: 'message', + T: TrajectoryConversionConfig, + }, + { + no: 6, + name: 'apply_model_default_override', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 7, + name: 'conversation_history_config', + kind: 'message', + T: ConversationHistoryConfig, + }, + { + no: 8, + name: 'split_dynamic_prompt_sections', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadeConfig, a, b); + } +}; +var TrajectoryConversionConfig = class _TrajectoryConversionConfig extends Message { + /** + * @generated from field: optional bool group_tools_with_planner_response = 3; + */ + groupToolsWithPlannerResponse; + /** + * If true, wraps the tool responses with xml tags and markdown code block, + * e.g. + * ``` + * ... + * ``` + * + * + * @generated from field: optional bool wrap_tool_responses = 5; + */ + wrapToolResponses; + /** + * Configures how trajectories are converted into overview and individual task + * artifacts + * + * @generated from field: exa.cortex_pb.LogArtifactsConfig log_artifacts_config = 6; + */ + logArtifactsConfig; + /** + * If true, ephemeral messages are appended to the previous tool result + * instead of being added as a separate message. + * + * @generated from field: optional bool append_ephemeral_to_previous_tool_result = 7; + */ + appendEphemeralToPreviousToolResult; + /** + * If true, disables "Step Id: " in the prompt for each message. + * + * @generated from field: optional bool disable_step_id = 8; + */ + disableStepId; + /** + * If true, disables all XML wrapping of user messages (i.e + * ... ) and just passes the raw text. NOTE: This will also + * prevent the presence of additional metadata in the user message. + * + * @generated from field: optional bool use_raw_user_message = 9; + */ + useRawUserMessage; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TrajectoryConversionConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 3, + name: 'group_tools_with_planner_response', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 5, name: 'wrap_tool_responses', kind: 'scalar', T: 8, opt: true }, + { + no: 6, + name: 'log_artifacts_config', + kind: 'message', + T: LogArtifactsConfig, + }, + { + no: 7, + name: 'append_ephemeral_to_previous_tool_result', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 8, name: 'disable_step_id', kind: 'scalar', T: 8, opt: true }, + { no: 9, name: 'use_raw_user_message', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _TrajectoryConversionConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TrajectoryConversionConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TrajectoryConversionConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_TrajectoryConversionConfig, a, b); + } +}; +var CascadeConversationalPlannerConfig = class _CascadeConversationalPlannerConfig extends Message { + /** + * Whether to give planner access to tools that can edit the filesystem. + * TODO(nicholasjiang): clean up usage, deprecated since read only mode is + * unsupported. + * + * @generated from field: exa.codeium_common_pb.ConversationalPlannerMode planner_mode = 4 [deprecated = true]; + * @deprecated + */ + plannerMode = ConversationalPlannerMode.UNSPECIFIED; + /** + * @generated from field: optional bool eval_mode = 5; + */ + evalMode; + /** + * @generated from field: optional bool agentic_mode = 14; + */ + agenticMode; + /** + * If this is set, it will override the system prompt with + * a named prompt combination defined in named_prompt_combination_registry. + * + * @generated from field: optional string prompt_combination_name = 15; + */ + promptCombinationName; + /** + * @generated from field: exa.cortex_pb.ConversationHistoryConfig conversation_history_config = 16; + */ + conversationHistoryConfig; + /** + * This overrides the workspace used in the system prompt. + * This is an experimental feature and *will* be removed in the future. + * + * @generated from field: optional string override_workspace_dir_experimental_use_only = 17; + */ + overrideWorkspaceDirExperimentalUseOnly; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeConversationalPlannerConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 4, + name: 'planner_mode', + kind: 'enum', + T: proto3.getEnumType(ConversationalPlannerMode), + }, + { no: 5, name: 'eval_mode', kind: 'scalar', T: 8, opt: true }, + { no: 14, name: 'agentic_mode', kind: 'scalar', T: 8, opt: true }, + { + no: 15, + name: 'prompt_combination_name', + kind: 'scalar', + T: 9, + opt: true, + }, + { + no: 16, + name: 'conversation_history_config', + kind: 'message', + T: ConversationHistoryConfig, + }, + { + no: 17, + name: 'override_workspace_dir_experimental_use_only', + kind: 'scalar', + T: 9, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeConversationalPlannerConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeConversationalPlannerConfig().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeConversationalPlannerConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeConversationalPlannerConfig, a, b); + } +}; +var SectionOverrideConfig = class _SectionOverrideConfig extends Message { + /** + * @generated from field: optional exa.cortex_pb.SectionOverrideMode mode = 1; + */ + mode; + /** + * @generated from field: optional string content = 2; + */ + content; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.SectionOverrideConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'mode', + kind: 'enum', + T: proto3.getEnumType(SectionOverrideMode), + opt: true, + }, + { no: 2, name: 'content', kind: 'scalar', T: 9, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _SectionOverrideConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SectionOverrideConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SectionOverrideConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SectionOverrideConfig, a, b); + } +}; +var MqueryToolConfig = class _MqueryToolConfig extends Message { + /** + * @generated from field: exa.codeium_common_pb.MQueryConfig m_query_config = 1; + */ + mQueryConfig; + /** + * @generated from field: exa.codeium_common_pb.Model m_query_model = 2; + */ + mQueryModel = Model.UNSPECIFIED; + /** + * @generated from field: uint32 max_tokens_per_m_query = 3; + */ + maxTokensPerMQuery = 0; + /** + * Number of items to show the full source for. + * + * @generated from field: optional int32 num_items_full_source = 4; + */ + numItemsFullSource; + /** + * @generated from field: int32 max_lines_per_snippet = 5; + */ + maxLinesPerSnippet = 0; + /** + * @generated from field: optional bool enable_search_in_file_tool = 6; + */ + enableSearchInFileTool; + /** + * If false, prevent access to these files if they are in .gitignore + * + * @generated from field: optional bool allow_access_gitignore = 7; + */ + allowAccessGitignore; + /** + * @generated from field: optional bool disable_semantic_codebase_search = 8 [deprecated = true]; + * @deprecated + */ + disableSemanticCodebaseSearch; + /** + * @generated from field: optional bool force_disable = 9; + */ + forceDisable; + /** + * Configuration that limits file access. TODO(matthewli): Rename this config + * + * @generated from field: exa.cortex_pb.EnterpriseToolConfig enterprise_config = 10; + */ + enterpriseConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.MqueryToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'm_query_config', kind: 'message', T: MQueryConfig }, + { + no: 2, + name: 'm_query_model', + kind: 'enum', + T: proto3.getEnumType(Model), + }, + { + no: 3, + name: 'max_tokens_per_m_query', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 4, name: 'num_items_full_source', kind: 'scalar', T: 5, opt: true }, + { + no: 5, + name: 'max_lines_per_snippet', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'enable_search_in_file_tool', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 7, name: 'allow_access_gitignore', kind: 'scalar', T: 8, opt: true }, + { + no: 8, + name: 'disable_semantic_codebase_search', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 9, name: 'force_disable', kind: 'scalar', T: 8, opt: true }, + { + no: 10, + name: 'enterprise_config', + kind: 'message', + T: EnterpriseToolConfig, + }, + ]); + static fromBinary(bytes, options) { + return new _MqueryToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MqueryToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MqueryToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_MqueryToolConfig, a, b); + } +}; +var NotifyUserConfig = class _NotifyUserConfig extends Message { + /** + * Controls when notify_user blocks based on confidence levels and document + * presence + * + * @generated from field: exa.codeium_common_pb.ArtifactReviewMode artifact_review_mode = 1; + */ + artifactReviewMode = ArtifactReviewMode.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.NotifyUserConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'artifact_review_mode', + kind: 'enum', + T: proto3.getEnumType(ArtifactReviewMode), + }, + ]); + static fromBinary(bytes, options) { + return new _NotifyUserConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _NotifyUserConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _NotifyUserConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_NotifyUserConfig, a, b); + } +}; +var GrepToolConfig = class _GrepToolConfig extends Message { + /** + * Max number of grep results returned to the model + * + * @generated from field: uint32 max_grep_results = 1; + */ + maxGrepResults = 0; + /** + * If true, then we'll retrieve the deepest child CCI that encapsulates the + * matching line The CCI's nodepath and potentially the CCI snippet will be + * included in the tool response + * + * @generated from field: optional bool include_cci_in_result = 2; + */ + includeCciInResult; + /** + * If there are fewer than num_full_source_ccis in the grep result + * then we'll include the CCI snippet in the tool response + * + * @generated from field: uint32 num_full_source_ccis = 3; + */ + numFullSourceCcis = 0; + /** + * If we include the CCI snippet, then we'll truncate it at max_bytes_per_cci + * using split truncation priority + * + * @generated from field: uint32 max_bytes_per_cci = 4; + */ + maxBytesPerCci = 0; + /** + * Configuration that limits file access. TODO(matthewli): Rename this config + * + * @generated from field: exa.cortex_pb.EnterpriseToolConfig enterprise_config = 5; + */ + enterpriseConfig; + /** + * If true, allows Cascade to search within .gitignored files + * Also inserts the --no-ignore-vcs flag in the ripgrep command + * + * @generated from field: optional bool allow_access_gitignore = 6; + */ + allowAccessGitignore; + /** + * whether to use the code_search tool + * + * @generated from field: optional bool use_code_search = 7; + */ + useCodeSearch; + /** + * Only relevant if use_code_search is true. + * Disables falling back to local grep execution if code search call fails for + * any reason. + * + * @generated from field: optional bool disable_fallback_to_local_execution = 8; + */ + disableFallbackToLocalExecution; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.GrepToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_grep_results', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 2, name: 'include_cci_in_result', kind: 'scalar', T: 8, opt: true }, + { + no: 3, + name: 'num_full_source_ccis', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'max_bytes_per_cci', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'enterprise_config', + kind: 'message', + T: EnterpriseToolConfig, + }, + { no: 6, name: 'allow_access_gitignore', kind: 'scalar', T: 8, opt: true }, + { no: 7, name: 'use_code_search', kind: 'scalar', T: 8, opt: true }, + { + no: 8, + name: 'disable_fallback_to_local_execution', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _GrepToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GrepToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GrepToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GrepToolConfig, a, b); + } +}; +var FindToolConfig = class _FindToolConfig extends Message { + /** + * @generated from field: uint32 max_find_results = 1; + */ + maxFindResults = 0; + /** + * @generated from field: string fd_path = 2; + */ + fdPath = ''; + /** + * whether to use the code_search tool + * + * @generated from field: optional bool use_code_search = 3; + */ + useCodeSearch; + /** + * Only relevant if use_code_search is true. + * Disables falling back to local find execution if code search call fails for + * any reason. + * + * @generated from field: optional bool disable_fallback_to_local_execution = 4; + */ + disableFallbackToLocalExecution; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FindToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_find_results', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'fd_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'use_code_search', kind: 'scalar', T: 8, opt: true }, + { + no: 4, + name: 'disable_fallback_to_local_execution', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _FindToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FindToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FindToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FindToolConfig, a, b); + } +}; +var CodeSearchToolConfig = class _CodeSearchToolConfig extends Message { + /** + * @generated from field: string cs_path = 1; + */ + csPath = ''; + /** + * @generated from field: optional bool use_eval_tag = 2; + */ + useEvalTag; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CodeSearchToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'cs_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'use_eval_tag', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _CodeSearchToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeSearchToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeSearchToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeSearchToolConfig, a, b); + } +}; +var InternalSearchToolConfig = class _InternalSearchToolConfig extends Message { + /** + * @generated from field: int32 max_results = 1; + */ + maxResults = 0; + /** + * @generated from field: int32 max_content_length = 2; + */ + maxContentLength = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.InternalSearchToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_results', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'max_content_length', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _InternalSearchToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _InternalSearchToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _InternalSearchToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_InternalSearchToolConfig, a, b); + } +}; +var ClusterQueryToolConfig = class _ClusterQueryToolConfig extends Message { + /** + * @generated from field: uint32 max_cluster_query_results = 1; + */ + maxClusterQueryResults = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ClusterQueryToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_cluster_query_results', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ClusterQueryToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ClusterQueryToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ClusterQueryToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ClusterQueryToolConfig, a, b); + } +}; +var InspectClusterToolConfig = class _InspectClusterToolConfig extends Message { + /** + * @generated from field: uint32 max_tokens_per_inspect_cluster = 1; + */ + maxTokensPerInspectCluster = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.InspectClusterToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_tokens_per_inspect_cluster', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _InspectClusterToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _InspectClusterToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _InspectClusterToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_InspectClusterToolConfig, a, b); + } +}; +var AutoCommandConfig = class _AutoCommandConfig extends Message { + /** + * If true, allows the model to decide if a command should be run without + * approval. This has lower precedence than the allow and denylists. + * + * @generated from field: optional bool enable_model_auto_run = 1 [deprecated = true]; + * @deprecated + */ + enableModelAutoRun; + /** + * Command prefixes that should always be auto-run, even if disagreeing with + * the model. A command prefix will match on a cmd + argument basis, as + * opposed to a string prefix. That is to say, each token of the prefix must + * exactly match and in the correct order. + * + * For example, the prefix `kubectl get` will match to `kubectl get pod` but + * not `kubectl delete`. The prefix `g` will not match to `git. + * + * @generated from field: repeated string user_allowlist = 2; + */ + userAllowlist = []; + /** + * Command prefixes that should never be auto-run, even if disagreeing with + * the model. + * + * @generated from field: repeated string user_denylist = 3; + */ + userDenylist = []; + /** + * Same as above, but for codeium-set defaults. If there is a conflict, the + * user settings will have higher precedence. + * + * @generated from field: repeated string system_allowlist = 4; + */ + systemAllowlist = []; + /** + * @generated from field: repeated string system_denylist = 5; + */ + systemDenylist = []; + /** + * Command prefixes that should always no-op, even if disagreeing with the + * model. Overrides user and system allow/denylists and is only used in eval + * mode. For example, we might want the model to make gh calls as part of eval + * but not want gh to actually do anything. We also don't want the gh to fail + * and then the model starts going off trying to get gh to work. + * + * @generated from field: repeated string system_nooplist = 7; + */ + systemNooplist = []; + /** + * Sets the auto command execution mode (deprecates enable_model_auto_run): + * - CASCADE_COMMANDS_AUTO_EXECUTION_OFF: Never auto-run commands. + * - CASCADE_COMMANDS_AUTO_EXECUTION_AUTO: Auto-run commands that the model + * approves. + * - CASCADE_COMMANDS_AUTO_EXECUTION_ON: Always auto-run commands. + * + * Note: this setting still respects the user and system allow/denylists. + * + * @generated from field: exa.codeium_common_pb.CascadeCommandsAutoExecution auto_execution_policy = 6; + */ + autoExecutionPolicy = CascadeCommandsAutoExecution.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.AutoCommandConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enable_model_auto_run', kind: 'scalar', T: 8, opt: true }, + { no: 2, name: 'user_allowlist', kind: 'scalar', T: 9, repeated: true }, + { no: 3, name: 'user_denylist', kind: 'scalar', T: 9, repeated: true }, + { no: 4, name: 'system_allowlist', kind: 'scalar', T: 9, repeated: true }, + { no: 5, name: 'system_denylist', kind: 'scalar', T: 9, repeated: true }, + { no: 7, name: 'system_nooplist', kind: 'scalar', T: 9, repeated: true }, + { + no: 6, + name: 'auto_execution_policy', + kind: 'enum', + T: proto3.getEnumType(CascadeCommandsAutoExecution), + }, + ]); + static fromBinary(bytes, options) { + return new _AutoCommandConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AutoCommandConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AutoCommandConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AutoCommandConfig, a, b); + } +}; +var ListDirToolConfig = class _ListDirToolConfig extends Message { + /** + * Configuration that limits file access. TODO(matthewli): Rename this config + * + * @generated from field: exa.cortex_pb.EnterpriseToolConfig enterprise_config = 1; + */ + enterpriseConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ListDirToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'enterprise_config', + kind: 'message', + T: EnterpriseToolConfig, + }, + ]); + static fromBinary(bytes, options) { + return new _ListDirToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ListDirToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ListDirToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ListDirToolConfig, a, b); + } +}; +var RunCommandToolConfig = class _RunCommandToolConfig extends Message { + /** + * @generated from field: uint32 max_chars_command_stdout = 1; + */ + maxCharsCommandStdout = 0; + /** + * @generated from field: optional bool force_disable = 2; + */ + forceDisable; + /** + * @generated from field: exa.cortex_pb.AutoCommandConfig auto_command_config = 3; + */ + autoCommandConfig; + /** + * If true, allows the model to execute commands in the IDE's terminal. + * + * @generated from field: optional bool enable_ide_terminal_execution = 4; + */ + enableIdeTerminalExecution; + /** + * Name of the shell (e.g. bash, zsh, fish, powershell, etc.) to use for + * terminal execution. Only relevant if enable_ide_terminal_execution is true. + * + * @generated from field: string shell_name = 5; + */ + shellName = ''; + /** + * Path to the shell (e.g. /bin/bash, /usr/bin/env bash, /usr/bin/zsh, + * /bin/fish, etc.). Only relevant if enable_ide_terminal_execution is true. + * + * @generated from field: string shell_path = 6; + */ + shellPath = ''; + /** + * Maximum time in milliseconds to wait for a command to complete. + * No timeout enforced if set to 0. + * + * @generated from field: uint32 max_timeout_ms = 7; + */ + maxTimeoutMs = 0; + /** + * Configuration that limits file access. TODO(matthewli): Rename this config + * + * @generated from field: exa.cortex_pb.EnterpriseToolConfig enterprise_config = 9; + */ + enterpriseConfig; + /** + * Script to run before every command. It will be concatenated along with a + * trailing space with the command, e.g. shell_setup_script + " " + command so + * it must have appropriate control operators. This is to work + * around the non-persistent shell. + * + * @generated from field: string shell_setup_script = 10; + */ + shellSetupScript = ''; + /** + * If true, forbids usage of grep and find (in favor of search tools). + * + * @generated from field: optional bool forbid_search_commands = 11; + */ + forbidSearchCommands; + /** + * If true, enables the midterm output processor. Only relevant if + * enable_ide_terminal_execution is true. + * + * @generated from field: optional bool enable_midterm_output_processor = 8 [deprecated = true]; + * @deprecated + */ + enableMidtermOutputProcessor; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.RunCommandToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_chars_command_stdout', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 2, name: 'force_disable', kind: 'scalar', T: 8, opt: true }, + { + no: 3, + name: 'auto_command_config', + kind: 'message', + T: AutoCommandConfig, + }, + { + no: 4, + name: 'enable_ide_terminal_execution', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 5, + name: 'shell_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'shell_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'max_timeout_ms', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 9, + name: 'enterprise_config', + kind: 'message', + T: EnterpriseToolConfig, + }, + { + no: 10, + name: 'shell_setup_script', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 11, name: 'forbid_search_commands', kind: 'scalar', T: 8, opt: true }, + { + no: 8, + name: 'enable_midterm_output_processor', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _RunCommandToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RunCommandToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RunCommandToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RunCommandToolConfig, a, b); + } +}; +var KnowledgeBaseSearchToolConfig = class _KnowledgeBaseSearchToolConfig extends Message { + /** + * @generated from field: uint32 max_tokens_per_knowledge_base_search = 1; + */ + maxTokensPerKnowledgeBaseSearch = 0; + /** + * @generated from field: optional double prompt_fraction = 2; + */ + promptFraction; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.KnowledgeBaseSearchToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_tokens_per_knowledge_base_search', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 2, name: 'prompt_fraction', kind: 'scalar', T: 1, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeBaseSearchToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeBaseSearchToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeBaseSearchToolConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeBaseSearchToolConfig, a, b); + } +}; +var FastApplyFallbackConfig = class _FastApplyFallbackConfig extends Message { + /** + * If true, then falls back to fast apply if the replacement fails. + * + * @generated from field: optional bool enabled = 1; + */ + enabled; + /** + * This controls how many unchanged lines to show around each diff block when + * constructing the fast apply prompt. + * + * @generated from field: uint32 prompt_unchanged_threshold = 2; + */ + promptUnchangedThreshold = 0; + /** + * The content sent to the fast apply model is the minimal contiguous range + * spanning all diff blocks, with a radius of unchanged lines on top. This + * parameter controls the radius. The larger this is, the longer the fast + * apply fallback will take, but the more context the model will have. + * + * @generated from field: uint32 content_view_radius_lines = 3; + */ + contentViewRadiusLines = 0; + /** + * Fast apply will make changes potentially to any area of the content sent + * over. Diffs outside of the minimal contiguous range will be ignored, with + * an optional radius of unchanged lines as buffer. + * + * @generated from field: uint32 content_edit_radius_lines = 4; + */ + contentEditRadiusLines = 0; + /** + * Model to use for fast apply. + * + * @generated from field: exa.codeium_common_pb.Model fast_apply_model = 5; + */ + fastApplyModel = Model.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FastApplyFallbackConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { + no: 2, + name: 'prompt_unchanged_threshold', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'content_view_radius_lines', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'content_edit_radius_lines', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'fast_apply_model', + kind: 'enum', + T: proto3.getEnumType(Model), + }, + ]); + static fromBinary(bytes, options) { + return new _FastApplyFallbackConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FastApplyFallbackConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FastApplyFallbackConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FastApplyFallbackConfig, a, b); + } +}; +var ReplaceContentToolConfig = class _ReplaceContentToolConfig extends Message { + /** + * @generated from field: float max_fuzzy_edit_distance_fraction = 1; + */ + maxFuzzyEditDistanceFraction = 0; + /** + * If true, will try to apply any chunks that match, even if some have + * + * @generated from field: bool allow_partial_replacement_success = 2; + */ + allowPartialReplacementSuccess = false; + /** + * matching errors. + * If non-zero, ephemeral message will encourage model to view file before + * editing. The value of the field determines the maximum step index distance + * to be considered recent. + * + * @generated from field: uint32 view_file_recency_max_distance = 3; + */ + viewFileRecencyMaxDistance = 0; + /** + * If the target and the fuzzy match are multi-line, and the first and last + * lines exactly match, then use the fuzzy replacement regardless of how much + * edit distance there is. + * + * @generated from field: bool enable_fuzzy_sandwich_match = 4; + */ + enableFuzzySandwichMatch = false; + /** + * Whether to fall back to fast apply in case of replacement failure. + * + * @generated from field: exa.cortex_pb.FastApplyFallbackConfig fast_apply_fallback_config = 5; + */ + fastApplyFallbackConfig; + /** + * Variant of the tool definition. + * + * @generated from field: exa.cortex_pb.ReplaceToolVariant tool_variant = 6 [deprecated = true]; + * @deprecated + */ + toolVariant = ReplaceToolVariant.UNSPECIFIED; + /** + * Whether to show triggered memories in the output + * + * @generated from field: optional bool show_triggered_memories = 8; + */ + showTriggeredMemories; + /** + * If true, then the model is not provided the option to set allowMultiple + * Default false (model can set allowMultiple) + * + * @generated from field: optional bool disable_allow_multiple = 9; + */ + disableAllowMultiple; + /** + * If true, then the tool will require the specification of line ranges for + * the replacement chunks + * + * @generated from field: optional bool use_line_range = 10; + */ + useLineRange; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ReplaceContentToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_fuzzy_edit_distance_fraction', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 2, + name: 'allow_partial_replacement_success', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'view_file_recency_max_distance', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'enable_fuzzy_sandwich_match', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'fast_apply_fallback_config', + kind: 'message', + T: FastApplyFallbackConfig, + }, + { + no: 6, + name: 'tool_variant', + kind: 'enum', + T: proto3.getEnumType(ReplaceToolVariant), + }, + { no: 8, name: 'show_triggered_memories', kind: 'scalar', T: 8, opt: true }, + { no: 9, name: 'disable_allow_multiple', kind: 'scalar', T: 8, opt: true }, + { no: 10, name: 'use_line_range', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _ReplaceContentToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ReplaceContentToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ReplaceContentToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ReplaceContentToolConfig, a, b); + } +}; +var CodeToolConfig = class _CodeToolConfig extends Message { + /** + * List of file extensions that should not be edited or created. + * + * @generated from field: repeated string disable_extensions = 1; + */ + disableExtensions = []; + /** + * @generated from field: optional bool apply_edits = 2; + */ + applyEdits; + /** + * @generated from field: optional bool use_replace_content_edit_tool = 3 [deprecated = true]; + * @deprecated + */ + useReplaceContentEditTool; + /** + * @generated from field: exa.cortex_pb.ReplaceContentToolConfig replace_content_tool_config = 4; + */ + replaceContentToolConfig; + /** + * @generated from field: exa.cortex_pb.AutoFixLintsConfig auto_fix_lints_config = 5; + */ + autoFixLintsConfig; + /** + * If true, then allow cascade to edit/create files in .gitignore + * + * @generated from field: optional bool allow_edit_gitignore = 6; + */ + allowEditGitignore; + /** + * Configuration that limits file access. TODO(matthewli): Rename this config + * + * @generated from field: exa.cortex_pb.EnterpriseToolConfig enterprise_config = 7; + */ + enterpriseConfig; + /** + * Additional params used by Tab models + * + * @generated from field: optional bool override_allow_action_on_unsaved_file = 8; + */ + overrideAllowActionOnUnsavedFile; + /** + * @generated from field: optional bool skip_replace_content_validation = 9; + */ + skipReplaceContentValidation; + /** + * If true, then use replace content style tool calls to propose code edits + * + * @generated from field: optional bool use_replace_content_propose_code = 10; + */ + useReplaceContentProposeCode; + /** + * If true, does not stack multiple diffs, only shows the latest diff. + * + * @generated from field: optional bool only_show_incremental_diff_zone = 11; + */ + onlyShowIncrementalDiffZone; + /** + * Optional file allowlist to limit the files that can be edited. Ignored if + * empty. + * + * @generated from field: repeated string file_allowlist = 12; + */ + fileAllowlist = []; + /** + * Optional directory allowlist to limit the directories that can be edited. + * Ignored if empty. + * + * @generated from field: repeated string dir_allowlist = 17; + */ + dirAllowlist = []; + /** + * If true, classify the edit for interactive cascade + * + * @generated from field: optional bool classify_edit = 13; + */ + classifyEdit; + /** + * @generated from field: optional bool run_proposal_extension_verifier = 14; + */ + runProposalExtensionVerifier; + /** + * If true, then we will not await lint errors before finishing in the + * handler. + * + * @generated from field: optional bool skip_await_lint_errors = 15; + */ + skipAwaitLintErrors; + /** + * If true, give the importance of the edit (for interactive cascade) + * + * @generated from field: optional bool provide_importance = 16; + */ + provideImportance; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CodeToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'disable_extensions', kind: 'scalar', T: 9, repeated: true }, + { no: 2, name: 'apply_edits', kind: 'scalar', T: 8, opt: true }, + { + no: 3, + name: 'use_replace_content_edit_tool', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 4, + name: 'replace_content_tool_config', + kind: 'message', + T: ReplaceContentToolConfig, + }, + { + no: 5, + name: 'auto_fix_lints_config', + kind: 'message', + T: AutoFixLintsConfig, + }, + { no: 6, name: 'allow_edit_gitignore', kind: 'scalar', T: 8, opt: true }, + { + no: 7, + name: 'enterprise_config', + kind: 'message', + T: EnterpriseToolConfig, + }, + { + no: 8, + name: 'override_allow_action_on_unsaved_file', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 9, + name: 'skip_replace_content_validation', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 10, + name: 'use_replace_content_propose_code', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 11, + name: 'only_show_incremental_diff_zone', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 12, name: 'file_allowlist', kind: 'scalar', T: 9, repeated: true }, + { no: 17, name: 'dir_allowlist', kind: 'scalar', T: 9, repeated: true }, + { no: 13, name: 'classify_edit', kind: 'scalar', T: 8, opt: true }, + { + no: 14, + name: 'run_proposal_extension_verifier', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 15, name: 'skip_await_lint_errors', kind: 'scalar', T: 8, opt: true }, + { no: 16, name: 'provide_importance', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _CodeToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeToolConfig, a, b); + } +}; +var IntentToolConfig = class _IntentToolConfig extends Message { + /** + * @generated from field: exa.codeium_common_pb.Model intent_model = 1; + */ + intentModel = Model.UNSPECIFIED; + /** + * @generated from field: uint32 max_context_tokens = 2; + */ + maxContextTokens = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.IntentToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'intent_model', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 2, + name: 'max_context_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _IntentToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _IntentToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _IntentToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_IntentToolConfig, a, b); + } +}; +var ViewFileToolConfig = class _ViewFileToolConfig extends Message { + /** + * If true, then Cascade can view files in .gitignore + * + * @generated from field: optional bool allow_view_gitignore = 7; + */ + allowViewGitignore; + /** + * If true, then enables a separate view file outline tool. + * + * @generated from field: optional bool split_outline_tool = 8; + */ + splitOutlineTool; + /** + * Whether or not to check which glob rules are triggered and return them in + * the triggeredMemories field + * + * @generated from field: optional bool show_triggered_memories = 13; + */ + showTriggeredMemories; + /** + * Configuration that limits file access. TODO(matthewli): Rename this config + * + * @generated from field: exa.cortex_pb.EnterpriseToolConfig enterprise_config = 12; + */ + enterpriseConfig; + /** + * The maximum number of lines that the model can view per tool call + * + * @generated from field: optional uint32 max_lines_per_view = 14; + */ + maxLinesPerView; + /** + * Whether to prepend each line of raw content with its line number + * + * @generated from field: optional bool include_line_numbers = 15; + */ + includeLineNumbers; + /** + * Optional directory allowlist to limit the directories that can be viewed. + * Ignored if empty. + * + * @generated from field: repeated string dir_allowlist = 16; + */ + dirAllowlist = []; + /** + * START - File outline specific configuration + * + * @generated from field: uint32 max_total_outline_bytes = 9; + */ + maxTotalOutlineBytes = 0; + /** + * @generated from field: uint32 max_bytes_per_outline_item = 11; + */ + maxBytesPerOutlineItem = 0; + /** + * When viewing an outline with offset 0, we will attempt to show the full + * file as long as it is less than this many bytes. + * + * END - File outline specific configuration + * + * @generated from field: optional uint32 show_full_file_bytes = 10; + */ + showFullFileBytes; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ViewFileToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 7, name: 'allow_view_gitignore', kind: 'scalar', T: 8, opt: true }, + { no: 8, name: 'split_outline_tool', kind: 'scalar', T: 8, opt: true }, + { + no: 13, + name: 'show_triggered_memories', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 12, + name: 'enterprise_config', + kind: 'message', + T: EnterpriseToolConfig, + }, + { no: 14, name: 'max_lines_per_view', kind: 'scalar', T: 13, opt: true }, + { no: 15, name: 'include_line_numbers', kind: 'scalar', T: 8, opt: true }, + { no: 16, name: 'dir_allowlist', kind: 'scalar', T: 9, repeated: true }, + { + no: 9, + name: 'max_total_outline_bytes', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 11, + name: 'max_bytes_per_outline_item', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 10, name: 'show_full_file_bytes', kind: 'scalar', T: 13, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _ViewFileToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ViewFileToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ViewFileToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ViewFileToolConfig, a, b); + } +}; +var SuggestedResponseConfig = class _SuggestedResponseConfig extends Message { + /** + * @generated from field: optional bool force_disable = 1; + */ + forceDisable; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.SuggestedResponseConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'force_disable', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _SuggestedResponseConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SuggestedResponseConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SuggestedResponseConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SuggestedResponseConfig, a, b); + } +}; +var SearchWebToolConfig = class _SearchWebToolConfig extends Message { + /** + * @generated from field: optional bool force_disable = 1; + */ + forceDisable; + /** + * @generated from field: optional exa.codeium_common_pb.ThirdPartyWebSearchConfig third_party_config = 2; + */ + thirdPartyConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.SearchWebToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'force_disable', kind: 'scalar', T: 8, opt: true }, + { + no: 2, + name: 'third_party_config', + kind: 'message', + T: ThirdPartyWebSearchConfig, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _SearchWebToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SearchWebToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SearchWebToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SearchWebToolConfig, a, b); + } +}; +var MemoryToolConfig = class _MemoryToolConfig extends Message { + /** + * Toggles both the memory tool and the memory retrieval system + * + * @generated from field: optional bool force_disable = 1; + */ + forceDisable; + /** + * If true, cascade will not create memories unless explicitly requested by + * the user + * + * @generated from field: optional bool disable_auto_generate_memories = 2; + */ + disableAutoGenerateMemories; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.MemoryToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'force_disable', kind: 'scalar', T: 8, opt: true }, + { + no: 2, + name: 'disable_auto_generate_memories', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _MemoryToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MemoryToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MemoryToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_MemoryToolConfig, a, b); + } +}; +var McpToolConfig = class _McpToolConfig extends Message { + /** + * @generated from field: optional bool force_disable = 1; + */ + forceDisable; + /** + * @generated from field: uint32 max_output_bytes = 2; + */ + maxOutputBytes = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.McpToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'force_disable', kind: 'scalar', T: 8, opt: true }, + { + no: 2, + name: 'max_output_bytes', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _McpToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpToolConfig, a, b); + } +}; +var InvokeSubagentToolConfig = class _InvokeSubagentToolConfig extends Message { + /** + * If true, enables the invoke_subagent tool. Defaults to false (disabled). + * + * @generated from field: optional bool enabled = 1; + */ + enabled; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.InvokeSubagentToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _InvokeSubagentToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _InvokeSubagentToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _InvokeSubagentToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_InvokeSubagentToolConfig, a, b); + } +}; +var AutoFixLintsConfig = class _AutoFixLintsConfig extends Message { + /** + * @generated from field: optional bool enabled = 1; + */ + enabled; + /** + * Specifies the opening section of the prompt string attached to a code + * action step, which tells the model that it's receiving IDE feedback about + * lint errors that the step created, as well as general guidelines on how to + * respond. + * + * @generated from field: optional string notifying_prompt = 2; + */ + notifyingPrompt; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.AutoFixLintsConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { no: 2, name: 'notifying_prompt', kind: 'scalar', T: 9, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _AutoFixLintsConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AutoFixLintsConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AutoFixLintsConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AutoFixLintsConfig, a, b); + } +}; +var CaptureBrowserScreenshotToolConfig = class _CaptureBrowserScreenshotToolConfig extends Message { + /** + * whether to allow the option to save the screenshot as an artifact + * + * @generated from field: optional bool enable_saving = 1; + */ + enableSaving; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CaptureBrowserScreenshotToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enable_saving', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _CaptureBrowserScreenshotToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CaptureBrowserScreenshotToolConfig().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CaptureBrowserScreenshotToolConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CaptureBrowserScreenshotToolConfig, a, b); + } +}; +var DOMExtractionConfig = class _DOMExtractionConfig extends Message { + /** + * If true, the extracted DOM will include scaled coordinates for interactive + * elements. + * + * @generated from field: optional bool include_coordinates = 1; + */ + includeCoordinates; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.DOMExtractionConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'include_coordinates', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _DOMExtractionConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DOMExtractionConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DOMExtractionConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_DOMExtractionConfig, a, b); + } +}; +var BrowserSubagentContextConfig = class _BrowserSubagentContextConfig extends Message { + /** + * Type of context to provide to the browser subagent. Defaults to + * WITH_MARKDOWN_TRAJECTORY_SUMMARY if not specified. + * + * @generated from field: optional exa.cortex_pb.BrowserSubagentContextConfig.ContextType type = 1; + */ + type; + /** + * Maximum characters for subagent context. Defaults to 10000 if not + * specified. + * + * @generated from field: optional int32 max_chars = 2; + */ + maxChars; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrowserSubagentContextConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(BrowserSubagentContextConfig_ContextType), + opt: true, + }, + { no: 2, name: 'max_chars', kind: 'scalar', T: 5, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _BrowserSubagentContextConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserSubagentContextConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserSubagentContextConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_BrowserSubagentContextConfig, a, b); + } +}; +var BrowserSubagentContextConfig_ContextType; +(function (BrowserSubagentContextConfig_ContextType2) { + BrowserSubagentContextConfig_ContextType2[ + (BrowserSubagentContextConfig_ContextType2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + BrowserSubagentContextConfig_ContextType2[ + (BrowserSubagentContextConfig_ContextType2[ + 'WITH_MARKDOWN_TRAJECTORY_SUMMARY' + ] = 1) + ] = 'WITH_MARKDOWN_TRAJECTORY_SUMMARY'; + BrowserSubagentContextConfig_ContextType2[ + (BrowserSubagentContextConfig_ContextType2['TASK_ONLY'] = 2) + ] = 'TASK_ONLY'; +})( + BrowserSubagentContextConfig_ContextType || + (BrowserSubagentContextConfig_ContextType = {}), +); +proto3.util.setEnumType( + BrowserSubagentContextConfig_ContextType, + 'exa.cortex_pb.BrowserSubagentContextConfig.ContextType', + [ + { no: 0, name: 'CONTEXT_TYPE_UNSPECIFIED' }, + { no: 1, name: 'CONTEXT_TYPE_WITH_MARKDOWN_TRAJECTORY_SUMMARY' }, + { no: 2, name: 'CONTEXT_TYPE_TASK_ONLY' }, + ], +); +var BrowserSubagentToolConfig = class _BrowserSubagentToolConfig extends Message { + /** + * Mode for browser tool distribution between main agent and subagent. + * Defaults to subagent-primarily if not specified. + * + * @generated from field: optional exa.cortex_pb.BrowserSubagentMode mode = 1; + */ + mode; + /** + * Model to use for the browser subagent + * + * @generated from field: exa.codeium_common_pb.Model browser_subagent_model = 2; + */ + browserSubagentModel = Model.UNSPECIFIED; + /** + * When true, includes subagent's tool calls and explanations in step output + * Defaults to false if not specified. + * + * @generated from field: optional bool use_detailed_converter = 3; + */ + useDetailedConverter; + /** + * The subagent is prompted to stop working after this many tool calls, + * though we do not enforce this in code. + * + * @generated from field: int32 suggested_max_tool_calls = 4; + */ + suggestedMaxToolCalls = 0; + /** + * When true, the agent will not try to onboard the user. + * + * @generated from field: optional bool disable_onboarding = 5; + */ + disableOnboarding; + /** + * Reminder mode for the planner after browser subagent steps. If nil, the + * planner will not be reminded to do anything based on the subagent output. + * + * @generated from field: exa.cortex_pb.SubagentReminderMode subagent_reminder_mode = 6; + */ + subagentReminderMode; + /** + * The maximum number of tokens that will be given to the subagent. If + * unspecified, only the usual model-specific token limits will be imposed. + * + * @generated from field: optional int32 max_context_tokens = 7; + */ + maxContextTokens; + /** + * Controls what context is provided to the browser subagent. Only applicable + * when mode is not MAIN_AGENT_ONLY (since there's no browser subagent in that + * mode). + * + * @generated from field: optional exa.cortex_pb.BrowserSubagentContextConfig context_config = 8; + */ + contextConfig; + /** + * Configuration for DOM extraction. + * + * @generated from field: optional exa.cortex_pb.DOMExtractionConfig dom_extraction_config = 9; + */ + domExtractionConfig; + /** + * If true, disables all browser screenshots for the browser subagent by + * removing tools that capture or return screenshots: + * - capture_browser_screenshot: explicit screenshot tool + * - click_browser_pixel: returns screenshot with click feedback + * - browser_drag_pixel_to_pixel: returns screenshot with drag feedback + * This setting is useful for training or evaluation scenarios where you want + * to remove all images from the model's input. + * + * @generated from field: optional bool disable_screenshot = 10; + */ + disableScreenshot; + /** + * Configuration for low-level browser tools like mouse_up/mouse_down. + * + * @generated from field: optional exa.cortex_pb.LowLevelToolsConfig low_level_tools_config = 11; + */ + lowLevelToolsConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrowserSubagentToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'mode', + kind: 'enum', + T: proto3.getEnumType(BrowserSubagentMode), + opt: true, + }, + { + no: 2, + name: 'browser_subagent_model', + kind: 'enum', + T: proto3.getEnumType(Model), + }, + { no: 3, name: 'use_detailed_converter', kind: 'scalar', T: 8, opt: true }, + { + no: 4, + name: 'suggested_max_tool_calls', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { no: 5, name: 'disable_onboarding', kind: 'scalar', T: 8, opt: true }, + { + no: 6, + name: 'subagent_reminder_mode', + kind: 'message', + T: SubagentReminderMode, + }, + { no: 7, name: 'max_context_tokens', kind: 'scalar', T: 5, opt: true }, + { + no: 8, + name: 'context_config', + kind: 'message', + T: BrowserSubagentContextConfig, + opt: true, + }, + { + no: 9, + name: 'dom_extraction_config', + kind: 'message', + T: DOMExtractionConfig, + opt: true, + }, + { no: 10, name: 'disable_screenshot', kind: 'scalar', T: 8, opt: true }, + { + no: 11, + name: 'low_level_tools_config', + kind: 'message', + T: LowLevelToolsConfig, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserSubagentToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserSubagentToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserSubagentToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserSubagentToolConfig, a, b); + } +}; +var SubagentReminderMode = class _SubagentReminderMode extends Message { + /** + * @generated from oneof exa.cortex_pb.SubagentReminderMode.mode + */ + mode = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.SubagentReminderMode'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'verify_screenshots', + kind: 'message', + T: BrowserVerifyScreenshotsMode, + oneof: 'mode', + }, + { + no: 2, + name: 'verify_completeness', + kind: 'message', + T: BrowserVerifyCompletenessMode, + oneof: 'mode', + }, + { + no: 3, + name: 'custom', + kind: 'message', + T: BrowserCustomReminderMode, + oneof: 'mode', + }, + ]); + static fromBinary(bytes, options) { + return new _SubagentReminderMode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SubagentReminderMode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SubagentReminderMode().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SubagentReminderMode, a, b); + } +}; +var BrowserVerifyScreenshotsMode = class _BrowserVerifyScreenshotsMode extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrowserVerifyScreenshotsMode'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _BrowserVerifyScreenshotsMode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserVerifyScreenshotsMode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserVerifyScreenshotsMode().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_BrowserVerifyScreenshotsMode, a, b); + } +}; +var BrowserVerifyCompletenessMode = class _BrowserVerifyCompletenessMode extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrowserVerifyCompletenessMode'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _BrowserVerifyCompletenessMode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserVerifyCompletenessMode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserVerifyCompletenessMode().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_BrowserVerifyCompletenessMode, a, b); + } +}; +var BrowserCustomReminderMode = class _BrowserCustomReminderMode extends Message { + /** + * The reminder to show to the planner after the subagent returns. + * + * @generated from field: string reminder = 1; + */ + reminder = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrowserCustomReminderMode'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'reminder', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserCustomReminderMode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserCustomReminderMode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserCustomReminderMode().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserCustomReminderMode, a, b); + } +}; +var ClickFeedbackConfig = class _ClickFeedbackConfig extends Message { + /** + * If true, a screenshot with the click's location will be shown to the model. + * + * @generated from field: optional bool enabled = 12; + */ + enabled; + /** + * Click dot color + * + * @generated from field: optional int32 red = 7; + */ + red; + /** + * @generated from field: optional int32 green = 8; + */ + green; + /** + * @generated from field: optional int32 blue = 9; + */ + blue; + /** + * @generated from field: optional int32 alpha = 10; + */ + alpha; + /** + * String description of the color. + * Used in the screenshot caption shown to the model. + * + * @generated from field: string display_color = 5; + */ + displayColor = ''; + /** + * Click dot radius + * + * @generated from field: optional int32 radius = 11; + */ + radius; + /** + * @generated from field: optional exa.cortex_pb.ClickFeedbackConfig.FeedbackType feedback_type = 13; + */ + feedbackType; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ClickFeedbackConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 12, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { no: 7, name: 'red', kind: 'scalar', T: 5, opt: true }, + { no: 8, name: 'green', kind: 'scalar', T: 5, opt: true }, + { no: 9, name: 'blue', kind: 'scalar', T: 5, opt: true }, + { no: 10, name: 'alpha', kind: 'scalar', T: 5, opt: true }, + { + no: 5, + name: 'display_color', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 11, name: 'radius', kind: 'scalar', T: 5, opt: true }, + { + no: 13, + name: 'feedback_type', + kind: 'enum', + T: proto3.getEnumType(ClickFeedbackConfig_FeedbackType), + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ClickFeedbackConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ClickFeedbackConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ClickFeedbackConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ClickFeedbackConfig, a, b); + } +}; +var ClickFeedbackConfig_FeedbackType; +(function (ClickFeedbackConfig_FeedbackType2) { + ClickFeedbackConfig_FeedbackType2[ + (ClickFeedbackConfig_FeedbackType2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + ClickFeedbackConfig_FeedbackType2[ + (ClickFeedbackConfig_FeedbackType2['DOT'] = 1) + ] = 'DOT'; + ClickFeedbackConfig_FeedbackType2[ + (ClickFeedbackConfig_FeedbackType2['MOUSE_POINTER'] = 2) + ] = 'MOUSE_POINTER'; +})(ClickFeedbackConfig_FeedbackType || (ClickFeedbackConfig_FeedbackType = {})); +proto3.util.setEnumType( + ClickFeedbackConfig_FeedbackType, + 'exa.cortex_pb.ClickFeedbackConfig.FeedbackType', + [ + { no: 0, name: 'FEEDBACK_TYPE_UNSPECIFIED' }, + { no: 1, name: 'FEEDBACK_TYPE_DOT' }, + { no: 2, name: 'FEEDBACK_TYPE_MOUSE_POINTER' }, + ], +); +var ClickBrowserPixelToolConfig = class _ClickBrowserPixelToolConfig extends Message { + /** + * If set, the tool output will include a screenshot of the current screen, + * with a dot marking the clicked pixel. + * + * @generated from field: exa.cortex_pb.ClickFeedbackConfig click_feedback = 1; + */ + clickFeedback; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ClickBrowserPixelToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'click_feedback', kind: 'message', T: ClickFeedbackConfig }, + ]); + static fromBinary(bytes, options) { + return new _ClickBrowserPixelToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ClickBrowserPixelToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ClickBrowserPixelToolConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ClickBrowserPixelToolConfig, a, b); + } +}; +var BrowserStateDiffingConfig = class _BrowserStateDiffingConfig extends Message { + /** + * If true, captures and displays browser state diffs with agent actions for + * the model. + * + * @generated from field: optional bool capture_agent_action_diffs = 1 [deprecated = true]; + * @deprecated + */ + captureAgentActionDiffs; + /** + * If true, includes DOM tree changes in browser state diffs. + * + * @generated from field: optional bool include_dom_tree_in_diffs = 2; + */ + includeDomTreeInDiffs; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrowserStateDiffingConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'capture_agent_action_diffs', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 2, + name: 'include_dom_tree_in_diffs', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserStateDiffingConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserStateDiffingConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserStateDiffingConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserStateDiffingConfig, a, b); + } +}; +var BrowserGetNetworkRequestToolConfig = class _BrowserGetNetworkRequestToolConfig extends Message { + /** + * @generated from field: optional bool enabled = 1; + */ + enabled; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrowserGetNetworkRequestToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _BrowserGetNetworkRequestToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserGetNetworkRequestToolConfig().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _BrowserGetNetworkRequestToolConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_BrowserGetNetworkRequestToolConfig, a, b); + } +}; +var LowLevelToolsConfig = class _LowLevelToolsConfig extends Message { + /** + * If true, adds instructions for how to use low level tools like mouse_up and + * mouse_down to the browser subagent system prompt. + * + * @generated from field: optional bool enable_low_level_tools_instructions = 1; + */ + enableLowLevelToolsInstructions; + /** + * If true, enables browser_mouse_up and browser_mouse_down tools for + * click and drag-and-drop operations. Defaults to false if not specified. + * + * @generated from field: optional bool enable_mouse_tools = 2; + */ + enableMouseTools; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.LowLevelToolsConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'enable_low_level_tools_instructions', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 2, name: 'enable_mouse_tools', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _LowLevelToolsConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LowLevelToolsConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LowLevelToolsConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_LowLevelToolsConfig, a, b); + } +}; +var BrowserWindowSize = class _BrowserWindowSize extends Message { + /** + * Browser window width in pixels. + * + * @generated from field: int32 width_px = 1; + */ + widthPx = 0; + /** + * Browser window height in pixels. + * + * @generated from field: int32 height_px = 2; + */ + heightPx = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrowserWindowSize'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'width_px', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'height_px', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserWindowSize().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserWindowSize().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserWindowSize().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrowserWindowSize, a, b); + } +}; +var BrowserListNetworkRequestsToolConfig = class _BrowserListNetworkRequestsToolConfig extends Message { + /** + * @generated from field: optional bool enabled = 1; + */ + enabled; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrowserListNetworkRequestsToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _BrowserListNetworkRequestsToolConfig().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _BrowserListNetworkRequestsToolConfig().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _BrowserListNetworkRequestsToolConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_BrowserListNetworkRequestsToolConfig, a, b); + } +}; +var AntigravityBrowserToolConfig = class _AntigravityBrowserToolConfig extends Message { + /** + * If true, browser tool is enabled. + * + * @generated from field: optional bool enabled = 1; + */ + enabled; + /** + * @generated from field: exa.cortex_pb.AutoRunDecision auto_run_decision = 2; + */ + autoRunDecision = AutoRunDecision.UNSPECIFIED; + /** + * @generated from field: exa.cortex_pb.CaptureBrowserScreenshotToolConfig capture_browser_screenshot = 3; + */ + captureBrowserScreenshot; + /** + * @generated from field: exa.cortex_pb.BrowserSubagentToolConfig browser_subagent = 4; + */ + browserSubagent; + /** + * @generated from field: exa.cortex_pb.ClickBrowserPixelToolConfig click_browser_pixel = 5; + */ + clickBrowserPixel; + /** + * @generated from field: exa.cortex_pb.BrowserStateDiffingConfig browser_state_diffing_config = 10; + */ + browserStateDiffingConfig; + /** + * @generated from field: exa.cortex_pb.BrowserListNetworkRequestsToolConfig browser_list_network_requests_tool_config = 18; + */ + browserListNetworkRequestsToolConfig; + /** + * @generated from field: exa.cortex_pb.BrowserGetNetworkRequestToolConfig browser_get_network_request_tool_config = 19; + */ + browserGetNetworkRequestToolConfig; + /** + * Filters which browser tools are available to the model. + * Note that the 'default' tool set can vary depending on the agent (main or + * subagent) being used. + * + * @generated from field: optional exa.cortex_pb.BrowserToolSetMode tool_set_mode = 6; + */ + toolSetMode; + /** + * If true, the agent will not try to open any new browser pages + * or navigate any current ones (useful for electron apps). + * + * @generated from field: optional bool disable_open_url = 7; + */ + disableOpenUrl; + /** + * DEPRECATED: Use use_extended_timeout, log_errors_instead_of_sentry, and + * skip_permission_checks instead. This field is kept for backward + * compatibility and will be removed in a future version. + * If true, browser will be launched on the same machine as language server, + * all validation will be skipped. + * + * @generated from field: optional bool is_eval_mode = 9 [deprecated = true]; + * @deprecated + */ + isEvalMode; + /** + * @generated from field: exa.codeium_common_pb.BrowserJsExecutionPolicy browser_js_execution_policy = 11; + */ + browserJsExecutionPolicy = BrowserJsExecutionPolicy.UNSPECIFIED; + /** + * If true, disables the actuation overlay (blue border and status messages) + * that appears during browser interactions. Useful for evals where the + * overlay might interfere with screenshots or visual testing. + * + * @generated from field: optional bool disable_actuation_overlay = 12; + */ + disableActuationOverlay; + /** + * If true, uses a wait tool with a variable duration instead of a fixed 5s + * duration. + * + * @generated from field: optional bool variable_wait_tool = 13; + */ + variableWaitTool; + /** + * This has been replaced with browser_js_execution_policy. + * + * @generated from field: exa.codeium_common_pb.BrowserJsAutoRunPolicy browser_js_auto_run_policy = 8 [deprecated = true]; + * @deprecated + */ + browserJsAutoRunPolicy = BrowserJsAutoRunPolicy.UNSPECIFIED; + /** + * Initial browser window size in pixels. If set, the browser window will be + * resized to these dimensions after launch using CDP Browser.setWindowBounds. + * + * @generated from field: optional exa.cortex_pb.BrowserWindowSize initial_browser_window_size = 14; + */ + initialBrowserWindowSize; + /** + * Configuration for DOM extraction. + * + * @generated from field: optional exa.cortex_pb.DOMExtractionConfig dom_extraction_config = 15; + */ + domExtractionConfig; + /** + * If true, disables the workspace_api tool for the browser subagent. + * This tool allows the agent to make authenticated requests to Google + * Workspace APIs (Docs, Sheets, Slides, Drive). + * + * @generated from field: optional bool disable_workspace_api = 16; + */ + disableWorkspaceApi; + /** + * If true, OpenUrl will open pages in the background instead of the + * foreground (focused). Default behavior (false) opens pages in the + * foreground so the user can see the browser window as pages are opened. + * + * @generated from field: optional bool open_page_in_background = 17; + */ + openPageInBackground; + /** + * @generated from field: optional bool use_antigravity_as_browser_prompting = 20; + */ + useAntigravityAsBrowserPrompting; + /** + * If true, enables the browser_refresh_page tool. + * + * @generated from field: optional bool enable_refresh_tool = 21; + */ + enableRefreshTool; + /** + * If true, disables the read_browser_page tool. + * + * @generated from field: optional bool disable_read_browser_page = 22; + */ + disableReadBrowserPage; + /** + * If true, uses a longer timeout (30s) for browser actions instead of the + * default (10s). This is useful for eval scenarios where actions may take + * longer. + * + * @generated from field: optional bool use_extended_timeout = 23; + */ + useExtendedTimeout; + /** + * If true, logs timeout errors to stderr instead of uploading to Sentry. + * This is useful for eval/testing scenarios. + * + * @generated from field: optional bool log_timeout_errors_instead_of_sentry = 24; + */ + logTimeoutErrorsInsteadOfSentry; + /** + * If true, skips all browser action permission checks. This is useful for + * eval scenarios where permission prompts would block automation. + * + * @generated from field: optional bool skip_permission_checks = 25; + */ + skipPermissionChecks; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.AntigravityBrowserToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { + no: 2, + name: 'auto_run_decision', + kind: 'enum', + T: proto3.getEnumType(AutoRunDecision), + }, + { + no: 3, + name: 'capture_browser_screenshot', + kind: 'message', + T: CaptureBrowserScreenshotToolConfig, + }, + { + no: 4, + name: 'browser_subagent', + kind: 'message', + T: BrowserSubagentToolConfig, + }, + { + no: 5, + name: 'click_browser_pixel', + kind: 'message', + T: ClickBrowserPixelToolConfig, + }, + { + no: 10, + name: 'browser_state_diffing_config', + kind: 'message', + T: BrowserStateDiffingConfig, + }, + { + no: 18, + name: 'browser_list_network_requests_tool_config', + kind: 'message', + T: BrowserListNetworkRequestsToolConfig, + }, + { + no: 19, + name: 'browser_get_network_request_tool_config', + kind: 'message', + T: BrowserGetNetworkRequestToolConfig, + }, + { + no: 6, + name: 'tool_set_mode', + kind: 'enum', + T: proto3.getEnumType(BrowserToolSetMode), + opt: true, + }, + { no: 7, name: 'disable_open_url', kind: 'scalar', T: 8, opt: true }, + { no: 9, name: 'is_eval_mode', kind: 'scalar', T: 8, opt: true }, + { + no: 11, + name: 'browser_js_execution_policy', + kind: 'enum', + T: proto3.getEnumType(BrowserJsExecutionPolicy), + }, + { + no: 12, + name: 'disable_actuation_overlay', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 13, name: 'variable_wait_tool', kind: 'scalar', T: 8, opt: true }, + { + no: 8, + name: 'browser_js_auto_run_policy', + kind: 'enum', + T: proto3.getEnumType(BrowserJsAutoRunPolicy), + }, + { + no: 14, + name: 'initial_browser_window_size', + kind: 'message', + T: BrowserWindowSize, + opt: true, + }, + { + no: 15, + name: 'dom_extraction_config', + kind: 'message', + T: DOMExtractionConfig, + opt: true, + }, + { no: 16, name: 'disable_workspace_api', kind: 'scalar', T: 8, opt: true }, + { + no: 17, + name: 'open_page_in_background', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 20, + name: 'use_antigravity_as_browser_prompting', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 21, name: 'enable_refresh_tool', kind: 'scalar', T: 8, opt: true }, + { + no: 22, + name: 'disable_read_browser_page', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 23, name: 'use_extended_timeout', kind: 'scalar', T: 8, opt: true }, + { + no: 24, + name: 'log_timeout_errors_instead_of_sentry', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 25, name: 'skip_permission_checks', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _AntigravityBrowserToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AntigravityBrowserToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AntigravityBrowserToolConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_AntigravityBrowserToolConfig, a, b); + } +}; +var TrajectorySearchToolConfig = class _TrajectorySearchToolConfig extends Message { + /** + * @generated from field: optional bool force_disable = 1; + */ + forceDisable; + /** + * @generated from field: optional bool conversations_enabled = 2; + */ + conversationsEnabled; + /** + * @generated from field: optional bool user_activities_enabled = 3; + */ + userActivitiesEnabled; + /** + * @generated from field: uint32 max_scored_chunks = 4; + */ + maxScoredChunks = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TrajectorySearchToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'force_disable', kind: 'scalar', T: 8, opt: true }, + { no: 2, name: 'conversations_enabled', kind: 'scalar', T: 8, opt: true }, + { no: 3, name: 'user_activities_enabled', kind: 'scalar', T: 8, opt: true }, + { + no: 4, + name: 'max_scored_chunks', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _TrajectorySearchToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TrajectorySearchToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TrajectorySearchToolConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_TrajectorySearchToolConfig, a, b); + } +}; +var EnterpriseToolConfig = class _EnterpriseToolConfig extends Message { + /** + * If true, enforces validation against workspace paths + * + * @generated from field: optional bool enforce_workspace_validation = 1; + */ + enforceWorkspaceValidation; + /** + * Custom workspace paths + * + * @generated from field: repeated string custom_workspace = 2; + */ + customWorkspace = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.EnterpriseToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'enforce_workspace_validation', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 2, name: 'custom_workspace', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _EnterpriseToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _EnterpriseToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _EnterpriseToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_EnterpriseToolConfig, a, b); + } +}; +var ViewCodeItemToolConfig = class _ViewCodeItemToolConfig extends Message { + /** + * If <= 1 or nil, then only allow a single item. + * + * @generated from field: optional uint32 max_num_items = 1; + */ + maxNumItems; + /** + * If 0 or nil, then unbounded. + * + * @generated from field: optional uint32 max_bytes_per_item = 2; + */ + maxBytesPerItem; + /** + * If false, prevent access to these files if they are in .gitignore + * + * @generated from field: optional bool allow_access_gitignore = 3; + */ + allowAccessGitignore; + /** + * Configuration that limits file access. TODO(matthewli): Rename this config + * + * @generated from field: exa.cortex_pb.EnterpriseToolConfig enterprise_config = 4; + */ + enterpriseConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ViewCodeItemToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'max_num_items', kind: 'scalar', T: 13, opt: true }, + { no: 2, name: 'max_bytes_per_item', kind: 'scalar', T: 13, opt: true }, + { no: 3, name: 'allow_access_gitignore', kind: 'scalar', T: 8, opt: true }, + { + no: 4, + name: 'enterprise_config', + kind: 'message', + T: EnterpriseToolConfig, + }, + ]); + static fromBinary(bytes, options) { + return new _ViewCodeItemToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ViewCodeItemToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ViewCodeItemToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ViewCodeItemToolConfig, a, b); + } +}; +var CommandStatusToolConfig = class _CommandStatusToolConfig extends Message { + /** + * If true, use delta output instead of full output. + * + * @generated from field: optional bool use_delta = 1; + */ + useDelta; + /** + * The maximum number of characters to return in the command output. + * + * @generated from field: optional int32 max_output_characters = 2; + */ + maxOutputCharacters; + /** + * The minimum number of characters to return in the command output. + * + * @generated from field: optional int32 min_output_characters = 3; + */ + minOutputCharacters; + /** + * The maximum duration in seconds to wait for a command to finish. + * + * @generated from field: optional int32 max_wait_duration_seconds = 4; + */ + maxWaitDurationSeconds; + /** + * The duration in seconds to wait for output to stabilize before returning. + * + * @generated from field: optional int32 output_stabilization_duration_seconds = 5; + */ + outputStabilizationDurationSeconds; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CommandStatusToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'use_delta', kind: 'scalar', T: 8, opt: true }, + { no: 2, name: 'max_output_characters', kind: 'scalar', T: 5, opt: true }, + { no: 3, name: 'min_output_characters', kind: 'scalar', T: 5, opt: true }, + { + no: 4, + name: 'max_wait_duration_seconds', + kind: 'scalar', + T: 5, + opt: true, + }, + { + no: 5, + name: 'output_stabilization_duration_seconds', + kind: 'scalar', + T: 5, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CommandStatusToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CommandStatusToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CommandStatusToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CommandStatusToolConfig, a, b); + } +}; +var ReadKnowledgeBaseItemToolConfig = class _ReadKnowledgeBaseItemToolConfig extends Message { + /** + * @generated from field: optional bool enabled = 1; + */ + enabled; + /** + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseItem knowledge_base_items = 2; + */ + knowledgeBaseItems = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ReadKnowledgeBaseItemToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { + no: 2, + name: 'knowledge_base_items', + kind: 'message', + T: KnowledgeBaseItem, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _ReadKnowledgeBaseItemToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ReadKnowledgeBaseItemToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ReadKnowledgeBaseItemToolConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ReadKnowledgeBaseItemToolConfig, a, b); + } +}; +var ToolOverrideConfig = class _ToolOverrideConfig extends Message { + /** + * Override the tool name shown to the model. If empty, the original name is + * used. + * + * @generated from field: optional string name_override = 1; + */ + nameOverride; + /** + * Map from original argument name to new argument name. Only arguments + * specified in this map will be renamed; others keep their original names. + * This supports partial overrides. + * + * @generated from field: map argument_name_overrides = 2; + */ + argumentNameOverrides = {}; + /** + * Override for the tool description. + * + * @generated from field: exa.cortex_pb.SectionOverrideConfig description_override = 3; + */ + descriptionOverride; + /** + * Map from original argument name to new description. Only arguments + * specified in this map will have their descriptions overridden. + * + * @generated from field: map argument_description_overrides = 4; + */ + argumentDescriptionOverrides = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ToolOverrideConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'name_override', kind: 'scalar', T: 9, opt: true }, + { + no: 2, + name: 'argument_name_overrides', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { + no: 3, + name: 'description_override', + kind: 'message', + T: SectionOverrideConfig, + }, + { + no: 4, + name: 'argument_description_overrides', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _ToolOverrideConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ToolOverrideConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ToolOverrideConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ToolOverrideConfig, a, b); + } +}; +var ToolDescriptionOverrideMap = class _ToolDescriptionOverrideMap extends Message { + /** + * DEPRECATED: Use tool_overrides instead. + * Legacy field for description-only overrides. Keyed by original tool name. + * + * @generated from field: map descriptions = 1 [deprecated = true]; + * @deprecated + */ + descriptions = {}; + /** + * Comprehensive tool overrides including name, argument renaming, and + * description. Keyed by original tool name. + * + * @generated from field: map tool_overrides = 2; + */ + toolOverrides = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ToolDescriptionOverrideMap'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'descriptions', + kind: 'map', + K: 9, + V: { kind: 'message', T: SectionOverrideConfig }, + }, + { + no: 2, + name: 'tool_overrides', + kind: 'map', + K: 9, + V: { kind: 'message', T: ToolOverrideConfig }, + }, + ]); + static fromBinary(bytes, options) { + return new _ToolDescriptionOverrideMap().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ToolDescriptionOverrideMap().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ToolDescriptionOverrideMap().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ToolDescriptionOverrideMap, a, b); + } +}; +var TaskBoundaryToolConfig = class _TaskBoundaryToolConfig extends Message { + /** + * If the predicted task size is fewer than this many tools, will prevent the + * task boundary creation. Set to 0 to disable. + * + * @generated from field: int32 minimum_predicted_task_size = 1; + */ + minimumPredictedTaskSize = 0; + /** + * The recommended number of tool calls that should separate task status + * updates within the task section. + * + * @generated from field: int32 target_status_update_frequency = 2; + */ + targetStatusUpdateFrequency = 0; + /** + * After this many tool calls, start to remind the model to call the task + * boundary tool. + * + * @generated from field: int32 no_active_task_soft_reminder_tool_threshold = 3; + */ + noActiveTaskSoftReminderToolThreshold = 0; + /** + * After this many tool calls, start to heavily encourage the model to call + * the task boundary tool. + * + * @generated from field: int32 no_active_task_strict_reminder_tool_threshold = 4; + */ + noActiveTaskStrictReminderToolThreshold = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TaskBoundaryToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'minimum_predicted_task_size', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'target_status_update_frequency', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'no_active_task_soft_reminder_tool_threshold', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'no_active_task_strict_reminder_tool_threshold', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _TaskBoundaryToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TaskBoundaryToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TaskBoundaryToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TaskBoundaryToolConfig, a, b); + } +}; +var FinishToolConfig = class _FinishToolConfig extends Message { + /** + * JSON schema string for the finish tool. Uses no arguments if empty string. + * Note configuring this field does not auto-include the tool, nor cause the + * execution to terminate on calling the finish tool. One must configure the + * other related settings for this. + * + * @generated from field: string result_json_schema_string = 1; + */ + resultJsonSchemaString = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FinishToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'result_json_schema_string', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _FinishToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FinishToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FinishToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FinishToolConfig, a, b); + } +}; +var WorkspaceAPIToolConfig = class _WorkspaceAPIToolConfig extends Message { + /** + * If true, the tool only allows GET requests (read-only mode). + * This is used for the main agent to prevent modifying Workspace documents. + * + * @generated from field: optional bool read_only = 1; + */ + readOnly; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.WorkspaceAPIToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'read_only', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _WorkspaceAPIToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WorkspaceAPIToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WorkspaceAPIToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_WorkspaceAPIToolConfig, a, b); + } +}; +var NotebookEditToolConfig = class _NotebookEditToolConfig extends Message { + /** + * @generated from field: optional bool enabled = 1; + */ + enabled; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.NotebookEditToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _NotebookEditToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _NotebookEditToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _NotebookEditToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_NotebookEditToolConfig, a, b); + } +}; +var CascadeToolConfig = class _CascadeToolConfig extends Message { + /** + * @generated from field: exa.cortex_pb.MqueryToolConfig mquery = 1; + */ + mquery; + /** + * @generated from field: exa.cortex_pb.CodeToolConfig code = 2; + */ + code; + /** + * @generated from field: exa.cortex_pb.IntentToolConfig intent = 3; + */ + intent; + /** + * @generated from field: exa.cortex_pb.GrepToolConfig grep = 4; + */ + grep; + /** + * @generated from field: exa.cortex_pb.FindToolConfig find = 5; + */ + find; + /** + * @generated from field: exa.cortex_pb.RunCommandToolConfig run_command = 8; + */ + runCommand; + /** + * @generated from field: exa.cortex_pb.KnowledgeBaseSearchToolConfig knowledge_base_search = 9; + */ + knowledgeBaseSearch; + /** + * @generated from field: exa.cortex_pb.ViewFileToolConfig view_file = 10; + */ + viewFile; + /** + * @generated from field: exa.cortex_pb.SuggestedResponseConfig suggested_response = 11; + */ + suggestedResponse; + /** + * @generated from field: exa.cortex_pb.SearchWebToolConfig search_web = 13; + */ + searchWeb; + /** + * @generated from field: exa.cortex_pb.MemoryToolConfig memory = 14 [deprecated = true]; + * @deprecated + */ + memory; + /** + * @generated from field: exa.cortex_pb.McpToolConfig mcp = 16; + */ + mcp; + /** + * @generated from field: exa.cortex_pb.ListDirToolConfig list_dir = 19; + */ + listDir; + /** + * @generated from field: exa.cortex_pb.ViewCodeItemToolConfig view_code_item = 20; + */ + viewCodeItem; + /** + * @generated from field: exa.cortex_pb.ReadKnowledgeBaseItemToolConfig read_knowledge_base_item = 21; + */ + readKnowledgeBaseItem; + /** + * @generated from field: exa.cortex_pb.CommandStatusToolConfig command_status = 23; + */ + commandStatus; + /** + * @generated from field: exa.cortex_pb.AntigravityBrowserToolConfig antigravity_browser = 25; + */ + antigravityBrowser; + /** + * @generated from field: exa.cortex_pb.TrajectorySearchToolConfig trajectory_search = 28; + */ + trajectorySearch; + /** + * @generated from field: exa.cortex_pb.CodeSearchToolConfig code_search = 31; + */ + codeSearch; + /** + * @generated from field: exa.cortex_pb.InternalSearchToolConfig internal_search = 32; + */ + internalSearch; + /** + * @generated from field: exa.cortex_pb.NotifyUserConfig notify_user = 33; + */ + notifyUser; + /** + * Deprecated, moved into AntigravityBrowserToolConfig. + * + * @generated from field: exa.cortex_pb.BrowserSubagentToolConfig browser_subagent = 34 [deprecated = true]; + * @deprecated + */ + browserSubagent; + /** + * @generated from field: exa.cortex_pb.TaskBoundaryToolConfig task_boundary = 35; + */ + taskBoundary; + /** + * @generated from field: exa.cortex_pb.FinishToolConfig finish = 36; + */ + finish; + /** + * @generated from field: exa.cortex_pb.WorkspaceAPIToolConfig workspace_api = 37; + */ + workspaceApi; + /** + * @generated from field: exa.cortex_pb.NotebookEditToolConfig notebook_edit = 38; + */ + notebookEdit; + /** + * @generated from field: exa.cortex_pb.InvokeSubagentToolConfig invoke_subagent = 39; + */ + invokeSubagent; + /** + * For tool description overrides + * + * @generated from field: exa.cortex_pb.ToolDescriptionOverrideMap description_override_map = 22; + */ + descriptionOverrideMap; + /** + * Disables grep_search, find_by_name, and list_dir + * + * @generated from field: optional bool disable_simple_research_tools = 29; + */ + disableSimpleResearchTools; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeToolConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'mquery', kind: 'message', T: MqueryToolConfig }, + { no: 2, name: 'code', kind: 'message', T: CodeToolConfig }, + { no: 3, name: 'intent', kind: 'message', T: IntentToolConfig }, + { no: 4, name: 'grep', kind: 'message', T: GrepToolConfig }, + { no: 5, name: 'find', kind: 'message', T: FindToolConfig }, + { no: 8, name: 'run_command', kind: 'message', T: RunCommandToolConfig }, + { + no: 9, + name: 'knowledge_base_search', + kind: 'message', + T: KnowledgeBaseSearchToolConfig, + }, + { no: 10, name: 'view_file', kind: 'message', T: ViewFileToolConfig }, + { + no: 11, + name: 'suggested_response', + kind: 'message', + T: SuggestedResponseConfig, + }, + { no: 13, name: 'search_web', kind: 'message', T: SearchWebToolConfig }, + { no: 14, name: 'memory', kind: 'message', T: MemoryToolConfig }, + { no: 16, name: 'mcp', kind: 'message', T: McpToolConfig }, + { no: 19, name: 'list_dir', kind: 'message', T: ListDirToolConfig }, + { + no: 20, + name: 'view_code_item', + kind: 'message', + T: ViewCodeItemToolConfig, + }, + { + no: 21, + name: 'read_knowledge_base_item', + kind: 'message', + T: ReadKnowledgeBaseItemToolConfig, + }, + { + no: 23, + name: 'command_status', + kind: 'message', + T: CommandStatusToolConfig, + }, + { + no: 25, + name: 'antigravity_browser', + kind: 'message', + T: AntigravityBrowserToolConfig, + }, + { + no: 28, + name: 'trajectory_search', + kind: 'message', + T: TrajectorySearchToolConfig, + }, + { no: 31, name: 'code_search', kind: 'message', T: CodeSearchToolConfig }, + { + no: 32, + name: 'internal_search', + kind: 'message', + T: InternalSearchToolConfig, + }, + { no: 33, name: 'notify_user', kind: 'message', T: NotifyUserConfig }, + { + no: 34, + name: 'browser_subagent', + kind: 'message', + T: BrowserSubagentToolConfig, + }, + { + no: 35, + name: 'task_boundary', + kind: 'message', + T: TaskBoundaryToolConfig, + }, + { no: 36, name: 'finish', kind: 'message', T: FinishToolConfig }, + { + no: 37, + name: 'workspace_api', + kind: 'message', + T: WorkspaceAPIToolConfig, + }, + { + no: 38, + name: 'notebook_edit', + kind: 'message', + T: NotebookEditToolConfig, + }, + { + no: 39, + name: 'invoke_subagent', + kind: 'message', + T: InvokeSubagentToolConfig, + }, + { + no: 22, + name: 'description_override_map', + kind: 'message', + T: ToolDescriptionOverrideMap, + }, + { + no: 29, + name: 'disable_simple_research_tools', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeToolConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeToolConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeToolConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadeToolConfig, a, b); + } +}; +var ModelOutputRetryConfig = class _ModelOutputRetryConfig extends Message { + /** + * @generated from field: uint32 max_retries = 1; + */ + maxRetries = 0; + /** + * If we are on the last of max_step_parse_retries, do not allow further tool + * calls. + * + * @generated from oneof exa.cortex_pb.ModelOutputRetryConfig.last_retry_option + */ + lastRetryOption = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ModelOutputRetryConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_retries', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'forbid_tool_use', + kind: 'scalar', + T: 8, + oneof: 'last_retry_option', + }, + { + no: 4, + name: 'force_tool_name', + kind: 'scalar', + T: 9, + oneof: 'last_retry_option', + }, + ]); + static fromBinary(bytes, options) { + return new _ModelOutputRetryConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelOutputRetryConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ModelOutputRetryConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ModelOutputRetryConfig, a, b); + } +}; +var ModelAPIRetryConfig = class _ModelAPIRetryConfig extends Message { + /** + * @generated from field: uint32 max_retries = 1; + */ + maxRetries = 0; + /** + * @generated from field: uint32 initial_sleep_duration_ms = 2; + */ + initialSleepDurationMs = 0; + /** + * @generated from field: double exponential_multiplier = 3; + */ + exponentialMultiplier = 0; + /** + * If true, include error messages in the prompt when retrying generations. + * If false, retries retryable errors with the same prompt. Used during + * training to avoid including error steps in training prompts. + * + * @generated from field: optional bool include_error_feedback = 4; + */ + includeErrorFeedback; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ModelAPIRetryConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_retries', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'initial_sleep_duration_ms', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'exponential_multiplier', + kind: 'scalar', + T: 1, + /* ScalarType.DOUBLE */ + }, + { no: 4, name: 'include_error_feedback', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _ModelAPIRetryConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelAPIRetryConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ModelAPIRetryConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ModelAPIRetryConfig, a, b); + } +}; +var PlannerRetryConfig = class _PlannerRetryConfig extends Message { + /** + * @generated from field: exa.cortex_pb.ModelOutputRetryConfig model_output_retry = 1; + */ + modelOutputRetry; + /** + * @generated from field: exa.cortex_pb.ModelAPIRetryConfig api_retry = 2; + */ + apiRetry; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.PlannerRetryConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'model_output_retry', + kind: 'message', + T: ModelOutputRetryConfig, + }, + { no: 2, name: 'api_retry', kind: 'message', T: ModelAPIRetryConfig }, + ]); + static fromBinary(bytes, options) { + return new _PlannerRetryConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PlannerRetryConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PlannerRetryConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PlannerRetryConfig, a, b); + } +}; +var CodeAcknowledgementConverterConfig = class _CodeAcknowledgementConverterConfig extends Message { + /** + * @generated from field: bool show_to_model_on_written_feedback = 1; + */ + showToModelOnWrittenFeedback = false; + /** + * @generated from field: bool show_to_model_on_rejection = 2; + */ + showToModelOnRejection = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CodeAcknowledgementConverterConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'show_to_model_on_written_feedback', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'show_to_model_on_rejection', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CodeAcknowledgementConverterConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeAcknowledgementConverterConfig().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CodeAcknowledgementConverterConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CodeAcknowledgementConverterConfig, a, b); + } +}; +var StepStringConverterConfig = class _StepStringConverterConfig extends Message { + /** + * @generated from field: exa.cortex_pb.CodeAcknowledgementConverterConfig code_acknowledgement = 1; + */ + codeAcknowledgement; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.StepStringConverterConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'code_acknowledgement', + kind: 'message', + T: CodeAcknowledgementConverterConfig, + }, + ]); + static fromBinary(bytes, options) { + return new _StepStringConverterConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StepStringConverterConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StepStringConverterConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_StepStringConverterConfig, a, b); + } +}; +var AgenticModeConfig = class _AgenticModeConfig extends Message { + /** + * Map from artifact filename to the number of tool calls since the last + * model interaction with that artifact before we show a reminder in an + * ephemeral message. If an artifact is not in the map or its threshold is 0, + * we do not show a reminder for that artifact. + * + * @generated from field: map inject_artifact_reminder_threshold_map = 1; + */ + injectArtifactReminderThresholdMap = {}; + /** + * If true, completely disables artifact reminders. + * + * @generated from field: optional bool disable_artifact_reminders = 2; + */ + disableArtifactReminders; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.AgenticModeConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'inject_artifact_reminder_threshold_map', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + }, + { + no: 2, + name: 'disable_artifact_reminders', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _AgenticModeConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _AgenticModeConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _AgenticModeConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_AgenticModeConfig, a, b); + } +}; +var CustomAgentSystemPromptConfig = class _CustomAgentSystemPromptConfig extends Message { + /** + * @generated from field: bool include_workspace_prompt = 1; + */ + includeWorkspacePrompt = false; + /** + * @generated from field: bool include_mcp_server_prompt = 2; + */ + includeMcpServerPrompt = false; + /** + * Includes information about where artifacts should be written to, and + * guidelines on allowed artifact format. Does not prescribe any specific + * artifact types. + * + * @generated from field: bool include_artifact_instructions = 3; + */ + includeArtifactInstructions = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CustomAgentSystemPromptConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'include_workspace_prompt', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'include_mcp_server_prompt', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'include_artifact_instructions', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CustomAgentSystemPromptConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CustomAgentSystemPromptConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CustomAgentSystemPromptConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CustomAgentSystemPromptConfig, a, b); + } +}; +var CustomAgentConfig = class _CustomAgentConfig extends Message { + /** + * @generated from field: repeated exa.cortex_pb.PromptSection system_prompt_sections = 1; + */ + systemPromptSections = []; + /** + * @generated from field: repeated string tool_names = 2; + */ + toolNames = []; + /** + * @generated from field: exa.cortex_pb.CustomAgentSystemPromptConfig system_prompt_config = 6; + */ + systemPromptConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CustomAgentConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'system_prompt_sections', + kind: 'message', + T: PromptSection, + repeated: true, + }, + { no: 2, name: 'tool_names', kind: 'scalar', T: 9, repeated: true }, + { + no: 6, + name: 'system_prompt_config', + kind: 'message', + T: CustomAgentSystemPromptConfig, + }, + ]); + static fromBinary(bytes, options) { + return new _CustomAgentConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CustomAgentConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CustomAgentConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CustomAgentConfig, a, b); + } +}; +var CodingAgentConfig = class _CodingAgentConfig extends Message { + /** + * @generated from field: bool google_mode = 1; + */ + googleMode = false; + /** + * @generated from field: bool agentic_mode = 2; + */ + agenticMode = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CodingAgentConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'google_mode', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'agentic_mode', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CodingAgentConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodingAgentConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodingAgentConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodingAgentConfig, a, b); + } +}; +var CustomAgentSpec = class _CustomAgentSpec extends Message { + /** + * @generated from oneof exa.cortex_pb.CustomAgentSpec.config + */ + config = { case: void 0 }; + /** + * @generated from field: repeated exa.cortex_pb.McpServerSpec mcp_servers = 4; + */ + mcpServers = []; + /** + * @generated from field: exa.cortex_pb.PromptSectionCustomizationConfig prompt_section_customization = 9; + */ + promptSectionCustomization; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CustomAgentSpec'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'custom_agent', + kind: 'message', + T: CustomAgentConfig, + oneof: 'config', + }, + { + no: 2, + name: 'coding_agent', + kind: 'message', + T: CodingAgentConfig, + oneof: 'config', + }, + { + no: 4, + name: 'mcp_servers', + kind: 'message', + T: McpServerSpec, + repeated: true, + }, + { + no: 9, + name: 'prompt_section_customization', + kind: 'message', + T: PromptSectionCustomizationConfig, + }, + ]); + static fromBinary(bytes, options) { + return new _CustomAgentSpec().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CustomAgentSpec().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CustomAgentSpec().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CustomAgentSpec, a, b); + } +}; +var CustomPromptSection = class _CustomPromptSection extends Message { + /** + * @generated from field: exa.cortex_pb.PromptSection prompt_section = 1; + */ + promptSection; + /** + * @generated from oneof exa.cortex_pb.CustomPromptSection.placement + */ + placement = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CustomPromptSection'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'prompt_section', kind: 'message', T: PromptSection }, + { + no: 2, + name: 'insert_after_section', + kind: 'scalar', + T: 9, + oneof: 'placement', + }, + { + no: 3, + name: 'insert_before_section', + kind: 'scalar', + T: 9, + oneof: 'placement', + }, + ]); + static fromBinary(bytes, options) { + return new _CustomPromptSection().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CustomPromptSection().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CustomPromptSection().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CustomPromptSection, a, b); + } +}; +var PromptSectionCustomizationConfig = class _PromptSectionCustomizationConfig extends Message { + /** + * @generated from field: repeated string remove_prompt_sections = 1; + */ + removePromptSections = []; + /** + * @generated from field: repeated exa.cortex_pb.CustomPromptSection add_prompt_sections = 2; + */ + addPromptSections = []; + /** + * These prompt sections are added to the END. + * Note that they will appear in the order specified. + * + * @generated from field: repeated exa.cortex_pb.PromptSection append_prompt_sections = 3; + */ + appendPromptSections = []; + /** + * These prompt sections replace existing sections with matching titles. + * + * @generated from field: repeated exa.cortex_pb.PromptSection replace_prompt_sections = 4; + */ + replacePromptSections = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.PromptSectionCustomizationConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'remove_prompt_sections', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 2, + name: 'add_prompt_sections', + kind: 'message', + T: CustomPromptSection, + repeated: true, + }, + { + no: 3, + name: 'append_prompt_sections', + kind: 'message', + T: PromptSection, + repeated: true, + }, + { + no: 4, + name: 'replace_prompt_sections', + kind: 'message', + T: PromptSection, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _PromptSectionCustomizationConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PromptSectionCustomizationConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PromptSectionCustomizationConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_PromptSectionCustomizationConfig, a, b); + } +}; +var WorkspacePaths = class _WorkspacePaths extends Message { + /** + * @generated from field: repeated string absolute_paths = 1; + */ + absolutePaths = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.WorkspacePaths'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'absolute_paths', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _WorkspacePaths().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _WorkspacePaths().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _WorkspacePaths().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_WorkspacePaths, a, b); + } +}; +var CustomizationConfig = class _CustomizationConfig extends Message { + /** + * Server that serves all customization functions. Should be an MCP server + * URL. + * + * @generated from field: string customization_server_url = 1; + */ + customizationServerUrl = ''; + /** + * Tool names to pass as agent tools from the customization server. + * + * @generated from field: repeated string tool_names = 2; + */ + toolNames = []; + /** + * Names of tools in the customization server that correspond to + * pre-invocation hooks. + * + * @generated from field: repeated string pre_invocation_hook_names = 3; + */ + preInvocationHookNames = []; + /** + * Names of tools in the customization server that correspond to + * post-invocation hooks. + * + * @generated from field: repeated string post_invocation_hook_names = 4; + */ + postInvocationHookNames = []; + /** + * MCP servers to be used directly. Overrides mcp servers read from any other + * source, e.g the mcp_config.json + * + * @generated from field: repeated exa.cortex_pb.McpServerSpec mcp_servers = 5; + */ + mcpServers = []; + /** + * If provided, overrides the trajectory to chat message behavior. Should be + * the name of a function in the customization server that returns a JSON of + * []*chat_pb.ChatMessagePrompt + * + * @generated from field: string trajectory_to_chat_message_override = 6; + */ + trajectoryToChatMessageOverride = ''; + /** + * Names of tools in the customization server that correspond to + * pre-tool hooks. + * + * @generated from field: repeated string pre_tool_hook_names = 8; + */ + preToolHookNames = []; + /** + * Names of tools in the customization server that correspond to + * post-tool hooks. + * + * @generated from field: repeated string post_tool_hook_names = 9; + */ + postToolHookNames = []; + /** + * @generated from oneof exa.cortex_pb.CustomizationConfig.workspace + */ + workspace = { case: void 0 }; + /** + * If true, tool names from the customization server will not be prefixed + * with mcp_{server_name}_. This allows customization tools to appear as + * native tools. + * + * @generated from field: bool skip_tool_name_prefix = 12; + */ + skipToolNamePrefix = false; + /** + * If true, tool descriptions from the customization server will not be + * prefixed with "This is a tool from the {server_name} MCP server." + * + * @generated from field: bool skip_tool_description_prefix = 13; + */ + skipToolDescriptionPrefix = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CustomizationConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'customization_server_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'tool_names', kind: 'scalar', T: 9, repeated: true }, + { + no: 3, + name: 'pre_invocation_hook_names', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 4, + name: 'post_invocation_hook_names', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 5, + name: 'mcp_servers', + kind: 'message', + T: McpServerSpec, + repeated: true, + }, + { + no: 6, + name: 'trajectory_to_chat_message_override', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'pre_tool_hook_names', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 9, + name: 'post_tool_hook_names', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 10, + name: 'user_active_workspaces', + kind: 'scalar', + T: 8, + oneof: 'workspace', + }, + { + no: 11, + name: 'workspace_paths', + kind: 'message', + T: WorkspacePaths, + oneof: 'workspace', + }, + { + no: 12, + name: 'skip_tool_name_prefix', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 13, + name: 'skip_tool_description_prefix', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CustomizationConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CustomizationConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CustomizationConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CustomizationConfig, a, b); + } +}; +var CascadePlannerConfig = class _CascadePlannerConfig extends Message { + /** + * The planner-type-config should be specific to the configuration of a mixin, + * i.e in deciding certain tools to use, or other mixin customizations. It + * should not contain any tool-level configuration. + * + * @generated from oneof exa.cortex_pb.CascadePlannerConfig.planner_type_config + */ + plannerTypeConfig = { case: void 0 }; + /** + * Configuration that specifies customizations to the agent. + * + * @generated from field: exa.cortex_pb.CustomizationConfig customization_config = 42; + */ + customizationConfig; + /** + * Used to mutate the prompt sections of an existing planner type + * + * @generated from field: exa.cortex_pb.PromptSectionCustomizationConfig prompt_section_customization_config = 41; + */ + promptSectionCustomizationConfig; + /** + * All tool-level configurations. + * + * @generated from field: exa.cortex_pb.CascadeToolConfig tool_config = 13; + */ + toolConfig; + /** + * @generated from field: exa.cortex_pb.StepStringConverterConfig step_string_converter_config = 31; + */ + stepStringConverterConfig; + /** + * All non-mixin-specific planner-level configurations. + * + * @generated from field: exa.codeium_common_pb.Model plan_model = 1; + */ + planModel = Model.UNSPECIFIED; + /** + * @generated from field: exa.codeium_common_pb.ModelOrAlias requested_model = 15; + */ + requestedModel; + /** + * @generated from field: string model_name = 28; + */ + modelName = ''; + /** + * Custom overrides for model info. Can have non-empty value if the model + * is marked with the supports_model_info_override feature. + * Must provide at minimum model_name field. + * + * @generated from field: exa.codeium_common_pb.ModelInfo custom_model_info_override = 27; + */ + customModelInfoOverride; + /** + * @generated from field: uint32 max_output_tokens = 6; + */ + maxOutputTokens = 0; + /** + * Whether to give explanation of tool calls or not. + * + * @generated from field: optional bool no_tool_explanation = 7; + */ + noToolExplanation; + /** + * Whether to give tool summary of tool calls or not. + * + * @generated from field: optional bool no_tool_summary = 33; + */ + noToolSummary; + /** + * If a conversation exceeds the truncation_threshold_tokens and the time + * since the last invocation is greater than the prompt cache TTL, we will + * proactively truncate the conversation back to the last checkpoint to + * prevent long latencies due to large cache writes. + * + * @generated from field: int32 truncation_threshold_tokens = 14; + */ + truncationThresholdTokens = 0; + /** + * Ephemeral message configuration. + * + * @generated from field: exa.cortex_pb.EphemeralMessagesConfig ephemeral_messages_config = 21; + */ + ephemeralMessagesConfig; + /** + * If true, then planner generator will mark all errors as shown to user. + * Otherwise only conditionally shows errors to user. + * + * @generated from field: bool show_all_errors = 25; + */ + showAllErrors = false; + /** + * Retry configuration for planner operations. + * + * @generated from field: exa.cortex_pb.PlannerRetryConfig retry_config = 30; + */ + retryConfig; + /** + * @generated from field: exa.cortex_pb.KnowledgeConfig knowledge_config = 32; + */ + knowledgeConfig; + /** + * Configures certain features specific to agentic mode. + * + * @generated from field: exa.cortex_pb.AgenticModeConfig agentic_mode_config = 35; + */ + agenticModeConfig; + /** + * Remove argument to allow model to queue / wait for previous tools. + * + * @generated from field: optional bool no_wait_for_previous_tools = 37; + */ + noWaitForPreviousTools; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadePlannerConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 2, + name: 'conversational', + kind: 'message', + T: CascadeConversationalPlannerConfig, + oneof: 'planner_type_config', + }, + { + no: 26, + name: 'google', + kind: 'message', + T: CascadeConversationalPlannerConfig, + oneof: 'planner_type_config', + }, + { + no: 36, + name: 'cider', + kind: 'message', + T: CascadeConversationalPlannerConfig, + oneof: 'planner_type_config', + }, + { + no: 39, + name: 'custom_agent', + kind: 'message', + T: CustomAgentConfig, + oneof: 'planner_type_config', + }, + { + no: 40, + name: 'custom_agent_config_absolute_uri', + kind: 'scalar', + T: 9, + oneof: 'planner_type_config', + }, + { + no: 42, + name: 'customization_config', + kind: 'message', + T: CustomizationConfig, + }, + { + no: 41, + name: 'prompt_section_customization_config', + kind: 'message', + T: PromptSectionCustomizationConfig, + }, + { no: 13, name: 'tool_config', kind: 'message', T: CascadeToolConfig }, + { + no: 31, + name: 'step_string_converter_config', + kind: 'message', + T: StepStringConverterConfig, + }, + { no: 1, name: 'plan_model', kind: 'enum', T: proto3.getEnumType(Model) }, + { no: 15, name: 'requested_model', kind: 'message', T: ModelOrAlias }, + { + no: 28, + name: 'model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 27, + name: 'custom_model_info_override', + kind: 'message', + T: ModelInfo, + }, + { + no: 6, + name: 'max_output_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 7, name: 'no_tool_explanation', kind: 'scalar', T: 8, opt: true }, + { no: 33, name: 'no_tool_summary', kind: 'scalar', T: 8, opt: true }, + { + no: 14, + name: 'truncation_threshold_tokens', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 21, + name: 'ephemeral_messages_config', + kind: 'message', + T: EphemeralMessagesConfig, + }, + { + no: 25, + name: 'show_all_errors', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 30, name: 'retry_config', kind: 'message', T: PlannerRetryConfig }, + { no: 32, name: 'knowledge_config', kind: 'message', T: KnowledgeConfig }, + { + no: 35, + name: 'agentic_mode_config', + kind: 'message', + T: AgenticModeConfig, + }, + { + no: 37, + name: 'no_wait_for_previous_tools', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CascadePlannerConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadePlannerConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadePlannerConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadePlannerConfig, a, b); + } +}; +var DeploymentInteractionPayload = class _DeploymentInteractionPayload extends Message { + /** + * @generated from field: string subdomain = 1; + */ + subdomain = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.DeploymentInteractionPayload'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'subdomain', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _DeploymentInteractionPayload().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DeploymentInteractionPayload().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DeploymentInteractionPayload().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_DeploymentInteractionPayload, a, b); + } +}; +var CascadeDeployInteraction = class _CascadeDeployInteraction extends Message { + /** + * @generated from field: bool cancel = 1; + */ + cancel = false; + /** + * @generated from field: exa.codeium_common_pb.DeployTarget deploy_target = 2; + */ + deployTarget; + /** + * @generated from field: string subdomain = 3; + */ + subdomain = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeDeployInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'cancel', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 2, name: 'deploy_target', kind: 'message', T: DeployTarget }, + { + no: 3, + name: 'subdomain', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeDeployInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeDeployInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeDeployInteraction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadeDeployInteraction, a, b); + } +}; +var CascadeRunCommandInteraction = class _CascadeRunCommandInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + /** + * Command that was initially proposed by the model. + * + * @generated from field: string proposed_command_line = 2; + */ + proposedCommandLine = ''; + /** + * Command that is to be run. This will be the same as the proposed command + * line if the user did not edit it. + * + * @generated from field: string submitted_command_line = 3; + */ + submittedCommandLine = ''; + /** + * @generated from field: bool sandbox_override = 4; + */ + sandboxOverride = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeRunCommandInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'proposed_command_line', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'submitted_command_line', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'sandbox_override', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeRunCommandInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeRunCommandInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeRunCommandInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeRunCommandInteraction, a, b); + } +}; +var CascadeOpenBrowserUrlInteraction = class _CascadeOpenBrowserUrlInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeOpenBrowserUrlInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeOpenBrowserUrlInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeOpenBrowserUrlInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeOpenBrowserUrlInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeOpenBrowserUrlInteraction, a, b); + } +}; +var CascadeRunExtensionCodeInteraction = class _CascadeRunExtensionCodeInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeRunExtensionCodeInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeRunExtensionCodeInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeRunExtensionCodeInteraction().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeRunExtensionCodeInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeRunExtensionCodeInteraction, a, b); + } +}; +var CascadeExecuteBrowserJavaScriptInteraction = class _CascadeExecuteBrowserJavaScriptInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeExecuteBrowserJavaScriptInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeExecuteBrowserJavaScriptInteraction().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeExecuteBrowserJavaScriptInteraction().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeExecuteBrowserJavaScriptInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals( + _CascadeExecuteBrowserJavaScriptInteraction, + a, + b, + ); + } +}; +var CascadeCaptureBrowserScreenshotInteraction = class _CascadeCaptureBrowserScreenshotInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeCaptureBrowserScreenshotInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeCaptureBrowserScreenshotInteraction().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeCaptureBrowserScreenshotInteraction().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeCaptureBrowserScreenshotInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals( + _CascadeCaptureBrowserScreenshotInteraction, + a, + b, + ); + } +}; +var CascadeClickBrowserPixelInteraction = class _CascadeClickBrowserPixelInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeClickBrowserPixelInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeClickBrowserPixelInteraction().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeClickBrowserPixelInteraction().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeClickBrowserPixelInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeClickBrowserPixelInteraction, a, b); + } +}; +var CascadeTaskResolutionInteraction = class _CascadeTaskResolutionInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + /** + * @generated from field: exa.cortex_pb.TaskResolution resolution = 2; + */ + resolution; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeTaskResolutionInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 2, name: 'resolution', kind: 'message', T: TaskResolution }, + ]); + static fromBinary(bytes, options) { + return new _CascadeTaskResolutionInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeTaskResolutionInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeTaskResolutionInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeTaskResolutionInteraction, a, b); + } +}; +var CascadeBrowserActionInteraction = class _CascadeBrowserActionInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeBrowserActionInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeBrowserActionInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeBrowserActionInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeBrowserActionInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeBrowserActionInteraction, a, b); + } +}; +var CascadeOpenBrowserSetupInteraction = class _CascadeOpenBrowserSetupInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeOpenBrowserSetupInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeOpenBrowserSetupInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeOpenBrowserSetupInteraction().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeOpenBrowserSetupInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeOpenBrowserSetupInteraction, a, b); + } +}; +var CascadeConfirmBrowserSetupInteraction = class _CascadeConfirmBrowserSetupInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeConfirmBrowserSetupInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeConfirmBrowserSetupInteraction().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeConfirmBrowserSetupInteraction().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeConfirmBrowserSetupInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeConfirmBrowserSetupInteraction, a, b); + } +}; +var CascadeSendCommandInputInteraction = class _CascadeSendCommandInputInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeSendCommandInputInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeSendCommandInputInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeSendCommandInputInteraction().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeSendCommandInputInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeSendCommandInputInteraction, a, b); + } +}; +var CascadeReadUrlContentInteraction = class _CascadeReadUrlContentInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeReadUrlContentInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeReadUrlContentInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeReadUrlContentInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeReadUrlContentInteraction().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeReadUrlContentInteraction, a, b); + } +}; +var CascadeMcpInteraction = class _CascadeMcpInteraction extends Message { + /** + * @generated from field: bool confirm = 1; + */ + confirm = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeMcpInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'confirm', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeMcpInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeMcpInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeMcpInteraction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadeMcpInteraction, a, b); + } +}; +var FilePermissionInteraction = class _FilePermissionInteraction extends Message { + /** + * true = grant access, false = deny access + * + * @generated from field: bool allow = 1; + */ + allow = false; + /** + * @generated from field: exa.cortex_pb.PermissionScope scope = 2; + */ + scope = PermissionScope.UNSPECIFIED; + /** + * @generated from field: string absolute_path_uri = 3; + */ + absolutePathUri = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FilePermissionInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'allow', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'scope', + kind: 'enum', + T: proto3.getEnumType(PermissionScope), + }, + { + no: 3, + name: 'absolute_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _FilePermissionInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FilePermissionInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FilePermissionInteraction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FilePermissionInteraction, a, b); + } +}; +var CascadeDeployInteractionSpec = class _CascadeDeployInteractionSpec extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.DeployTarget deploy_target_options = 1; + */ + deployTargetOptions = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeDeployInteractionSpec'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'deploy_target_options', + kind: 'message', + T: DeployTarget, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeDeployInteractionSpec().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeDeployInteractionSpec().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeDeployInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeDeployInteractionSpec, a, b); + } +}; +var CascadeRunCommandInteractionSpec = class _CascadeRunCommandInteractionSpec extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeRunCommandInteractionSpec'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CascadeRunCommandInteractionSpec().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeRunCommandInteractionSpec().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeRunCommandInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeRunCommandInteractionSpec, a, b); + } +}; +var CascadeOpenBrowserUrlInteractionSpec = class _CascadeOpenBrowserUrlInteractionSpec extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeOpenBrowserUrlInteractionSpec'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CascadeOpenBrowserUrlInteractionSpec().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeOpenBrowserUrlInteractionSpec().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeOpenBrowserUrlInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeOpenBrowserUrlInteractionSpec, a, b); + } +}; +var CascadeRunExtensionCodeInteractionSpec = class _CascadeRunExtensionCodeInteractionSpec extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeRunExtensionCodeInteractionSpec'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CascadeRunExtensionCodeInteractionSpec().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeRunExtensionCodeInteractionSpec().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeRunExtensionCodeInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeRunExtensionCodeInteractionSpec, a, b); + } +}; +var CascadeExecuteBrowserJavaScriptInteractionSpec = class _CascadeExecuteBrowserJavaScriptInteractionSpec extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.cortex_pb.CascadeExecuteBrowserJavaScriptInteractionSpec'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CascadeExecuteBrowserJavaScriptInteractionSpec().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeExecuteBrowserJavaScriptInteractionSpec().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeExecuteBrowserJavaScriptInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals( + _CascadeExecuteBrowserJavaScriptInteractionSpec, + a, + b, + ); + } +}; +var CascadeCaptureBrowserScreenshotInteractionSpec = class _CascadeCaptureBrowserScreenshotInteractionSpec extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = + 'exa.cortex_pb.CascadeCaptureBrowserScreenshotInteractionSpec'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CascadeCaptureBrowserScreenshotInteractionSpec().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeCaptureBrowserScreenshotInteractionSpec().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeCaptureBrowserScreenshotInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals( + _CascadeCaptureBrowserScreenshotInteractionSpec, + a, + b, + ); + } +}; +var CascadeClickBrowserPixelInteractionSpec = class _CascadeClickBrowserPixelInteractionSpec extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeClickBrowserPixelInteractionSpec'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CascadeClickBrowserPixelInteractionSpec().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeClickBrowserPixelInteractionSpec().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeClickBrowserPixelInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeClickBrowserPixelInteractionSpec, a, b); + } +}; +var CascadeTaskResolutionInteractionSpec = class _CascadeTaskResolutionInteractionSpec extends Message { + /** + * @generated from field: string title = 1; + */ + title = ''; + /** + * @generated from field: string description = 2; + */ + description = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeTaskResolutionInteractionSpec'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeTaskResolutionInteractionSpec().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeTaskResolutionInteractionSpec().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeTaskResolutionInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeTaskResolutionInteractionSpec, a, b); + } +}; +var CascadeSendCommandInputInteractionSpec = class _CascadeSendCommandInputInteractionSpec extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeSendCommandInputInteractionSpec'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CascadeSendCommandInputInteractionSpec().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeSendCommandInputInteractionSpec().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeSendCommandInputInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeSendCommandInputInteractionSpec, a, b); + } +}; +var CascadeReadUrlContentInteractionSpec = class _CascadeReadUrlContentInteractionSpec extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeReadUrlContentInteractionSpec'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CascadeReadUrlContentInteractionSpec().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CascadeReadUrlContentInteractionSpec().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CascadeReadUrlContentInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CascadeReadUrlContentInteractionSpec, a, b); + } +}; +var CascadeMcpInteractionSpec = class _CascadeMcpInteractionSpec extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeMcpInteractionSpec'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CascadeMcpInteractionSpec().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeMcpInteractionSpec().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeMcpInteractionSpec().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadeMcpInteractionSpec, a, b); + } +}; +var FilePermissionInteractionSpec = class _FilePermissionInteractionSpec extends Message { + /** + * @generated from field: string absolute_path_uri = 1; + */ + absolutePathUri = ''; + /** + * @generated from field: bool is_directory = 2; + */ + isDirectory = false; + /** + * @generated from field: exa.cortex_pb.FilePermissionInteractionSpec.BlockReason block_reason = 3; + */ + blockReason = FilePermissionInteractionSpec_BlockReason.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FilePermissionInteractionSpec'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'is_directory', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'block_reason', + kind: 'enum', + T: proto3.getEnumType(FilePermissionInteractionSpec_BlockReason), + }, + ]); + static fromBinary(bytes, options) { + return new _FilePermissionInteractionSpec().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FilePermissionInteractionSpec().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FilePermissionInteractionSpec().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_FilePermissionInteractionSpec, a, b); + } +}; +var FilePermissionInteractionSpec_BlockReason; +(function (FilePermissionInteractionSpec_BlockReason2) { + FilePermissionInteractionSpec_BlockReason2[ + (FilePermissionInteractionSpec_BlockReason2['UNSPECIFIED'] = 0) + ] = 'UNSPECIFIED'; + FilePermissionInteractionSpec_BlockReason2[ + (FilePermissionInteractionSpec_BlockReason2['OUTSIDE_WORKSPACE'] = 1) + ] = 'OUTSIDE_WORKSPACE'; + FilePermissionInteractionSpec_BlockReason2[ + (FilePermissionInteractionSpec_BlockReason2['GITIGNORED'] = 2) + ] = 'GITIGNORED'; +})( + FilePermissionInteractionSpec_BlockReason || + (FilePermissionInteractionSpec_BlockReason = {}), +); +proto3.util.setEnumType( + FilePermissionInteractionSpec_BlockReason, + 'exa.cortex_pb.FilePermissionInteractionSpec.BlockReason', + [ + { no: 0, name: 'BLOCK_REASON_UNSPECIFIED' }, + { no: 1, name: 'BLOCK_REASON_OUTSIDE_WORKSPACE' }, + { no: 2, name: 'BLOCK_REASON_GITIGNORED' }, + ], +); +var RequestedInteraction = class _RequestedInteraction extends Message { + /** + * @generated from oneof exa.cortex_pb.RequestedInteraction.interaction + */ + interaction = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.RequestedInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 2, + name: 'deploy', + kind: 'message', + T: CascadeDeployInteractionSpec, + oneof: 'interaction', + }, + { + no: 3, + name: 'run_command', + kind: 'message', + T: CascadeRunCommandInteractionSpec, + oneof: 'interaction', + }, + { + no: 4, + name: 'open_browser_url', + kind: 'message', + T: CascadeOpenBrowserUrlInteractionSpec, + oneof: 'interaction', + }, + { + no: 5, + name: 'run_extension_code', + kind: 'message', + T: CascadeRunExtensionCodeInteractionSpec, + oneof: 'interaction', + }, + { + no: 7, + name: 'execute_browser_javascript', + kind: 'message', + T: CascadeExecuteBrowserJavaScriptInteractionSpec, + oneof: 'interaction', + }, + { + no: 8, + name: 'capture_browser_screenshot', + kind: 'message', + T: CascadeCaptureBrowserScreenshotInteractionSpec, + oneof: 'interaction', + }, + { + no: 9, + name: 'click_browser_pixel', + kind: 'message', + T: CascadeClickBrowserPixelInteractionSpec, + oneof: 'interaction', + }, + { + no: 13, + name: 'browser_action', + kind: 'message', + T: CascadeBrowserActionInteraction, + oneof: 'interaction', + }, + { + no: 14, + name: 'open_browser_setup', + kind: 'message', + T: CascadeOpenBrowserSetupInteraction, + oneof: 'interaction', + }, + { + no: 15, + name: 'confirm_browser_setup', + kind: 'message', + T: CascadeConfirmBrowserSetupInteraction, + oneof: 'interaction', + }, + { + no: 16, + name: 'send_command_input', + kind: 'message', + T: CascadeSendCommandInputInteractionSpec, + oneof: 'interaction', + }, + { + no: 17, + name: 'read_url_content', + kind: 'message', + T: CascadeReadUrlContentInteractionSpec, + oneof: 'interaction', + }, + { + no: 18, + name: 'mcp', + kind: 'message', + T: CascadeMcpInteractionSpec, + oneof: 'interaction', + }, + { + no: 19, + name: 'file_permission', + kind: 'message', + T: FilePermissionInteractionSpec, + oneof: 'interaction', + }, + ]); + static fromBinary(bytes, options) { + return new _RequestedInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RequestedInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RequestedInteraction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RequestedInteraction, a, b); + } +}; +var CascadeUserInteraction = class _CascadeUserInteraction extends Message { + /** + * @generated from field: string trajectory_id = 1; + */ + trajectoryId = ''; + /** + * @generated from field: uint32 step_index = 2; + */ + stepIndex = 0; + /** + * @generated from oneof exa.cortex_pb.CascadeUserInteraction.interaction + */ + interaction = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadeUserInteraction'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'trajectory_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'step_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'deploy', + kind: 'message', + T: CascadeDeployInteraction, + oneof: 'interaction', + }, + { + no: 5, + name: 'run_command', + kind: 'message', + T: CascadeRunCommandInteraction, + oneof: 'interaction', + }, + { + no: 6, + name: 'open_browser_url', + kind: 'message', + T: CascadeOpenBrowserUrlInteraction, + oneof: 'interaction', + }, + { + no: 7, + name: 'run_extension_code', + kind: 'message', + T: CascadeRunExtensionCodeInteraction, + oneof: 'interaction', + }, + { + no: 8, + name: 'execute_browser_javascript', + kind: 'message', + T: CascadeExecuteBrowserJavaScriptInteraction, + oneof: 'interaction', + }, + { + no: 9, + name: 'capture_browser_screenshot', + kind: 'message', + T: CascadeCaptureBrowserScreenshotInteraction, + oneof: 'interaction', + }, + { + no: 10, + name: 'click_browser_pixel', + kind: 'message', + T: CascadeClickBrowserPixelInteraction, + oneof: 'interaction', + }, + { + no: 13, + name: 'browser_action', + kind: 'message', + T: CascadeBrowserActionInteraction, + oneof: 'interaction', + }, + { + no: 14, + name: 'open_browser_setup', + kind: 'message', + T: CascadeOpenBrowserSetupInteraction, + oneof: 'interaction', + }, + { + no: 15, + name: 'confirm_browser_setup', + kind: 'message', + T: CascadeConfirmBrowserSetupInteraction, + oneof: 'interaction', + }, + { + no: 16, + name: 'send_command_input', + kind: 'message', + T: CascadeSendCommandInputInteraction, + oneof: 'interaction', + }, + { + no: 17, + name: 'read_url_content', + kind: 'message', + T: CascadeReadUrlContentInteraction, + oneof: 'interaction', + }, + { + no: 18, + name: 'mcp', + kind: 'message', + T: CascadeMcpInteraction, + oneof: 'interaction', + }, + { + no: 19, + name: 'file_permission', + kind: 'message', + T: FilePermissionInteraction, + oneof: 'interaction', + }, + ]); + static fromBinary(bytes, options) { + return new _CascadeUserInteraction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadeUserInteraction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadeUserInteraction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadeUserInteraction, a, b); + } +}; +var KnowledgeReference = class _KnowledgeReference extends Message { + /** + * @generated from oneof exa.cortex_pb.KnowledgeReference.reference + */ + reference = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.KnowledgeReference'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'file_path', kind: 'scalar', T: 9, oneof: 'reference' }, + { + no: 2, + name: 'conversation_id', + kind: 'scalar', + T: 9, + oneof: 'reference', + }, + { no: 3, name: 'url', kind: 'scalar', T: 9, oneof: 'reference' }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeReference().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeReference().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeReference().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeReference, a, b); + } +}; +var KnowledgeReferences = class _KnowledgeReferences extends Message { + /** + * @generated from field: repeated exa.cortex_pb.KnowledgeReference references = 1; + */ + references = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.KnowledgeReferences'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'references', + kind: 'message', + T: KnowledgeReference, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeReferences().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeReferences().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeReferences().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeReferences, a, b); + } +}; +var CortexStepKIInsertion = class _CortexStepKIInsertion extends Message { + /** + * map of KI names to their references + * + * @generated from field: map ki_references = 1; + */ + kiReferences = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepKIInsertion'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'ki_references', + kind: 'map', + K: 9, + V: { kind: 'message', T: KnowledgeReferences }, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepKIInsertion().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepKIInsertion().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepKIInsertion().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepKIInsertion, a, b); + } +}; +var CortexStepDummy = class _CortexStepDummy extends Message { + /** + * @generated from field: uint32 input = 1; + */ + input = 0; + /** + * @generated from field: uint32 output = 2; + */ + output = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepDummy'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'input', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'output', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepDummy().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepDummy().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepDummy().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepDummy, a, b); + } +}; +var CortexStepFinish = class _CortexStepFinish extends Message { + /** + * @generated from field: map output = 1; + */ + output = {}; + /** + * @generated from field: string output_string = 2; + */ + outputString = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepFinish'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'output', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { + no: 2, + name: 'output_string', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepFinish().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepFinish().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepFinish().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepFinish, a, b); + } +}; +var CortexStepPlanInput = class _CortexStepPlanInput extends Message { + /** + * @generated from field: exa.cortex_pb.PlanInput plan_input = 1; + */ + planInput; + /** + * @generated from field: bool user_provided = 2; + */ + userProvided = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepPlanInput'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'plan_input', kind: 'message', T: PlanInput }, + { + no: 2, + name: 'user_provided', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepPlanInput().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepPlanInput().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepPlanInput().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepPlanInput, a, b); + } +}; +var ArtifactSnapshot = class _ArtifactSnapshot extends Message { + /** + * @generated from field: string artifact_name = 1; + */ + artifactName = ''; + /** + * Content is only populated if the artifact is a text file. Might not be + * populated at all, depending on the method used to generate the snapshot. + * + * @generated from field: string content = 2; + */ + content = ''; + /** + * @generated from field: string artifact_absolute_uri = 3; + */ + artifactAbsoluteUri = ''; + /** + * @generated from field: google.protobuf.Timestamp last_edited = 4; + */ + lastEdited; + /** + * @generated from field: exa.cortex_pb.ArtifactReviewState review_state = 5; + */ + reviewState; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ArtifactSnapshot'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'artifact_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'artifact_absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'last_edited', kind: 'message', T: Timestamp }, + { no: 5, name: 'review_state', kind: 'message', T: ArtifactReviewState }, + ]); + static fromBinary(bytes, options) { + return new _ArtifactSnapshot().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ArtifactSnapshot().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ArtifactSnapshot().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ArtifactSnapshot, a, b); + } +}; +var CortexStepCheckpoint = class _CortexStepCheckpoint extends Message { + /** + * Inputs + * + * 0-indexed + * + * @generated from field: uint32 checkpoint_index = 1; + */ + checkpointIndex = 0; + /** + * If true, performs a minimal checkpoint and only + * + * @generated from field: bool intent_only = 9; + */ + intentOnly = false; + /** + * Outputs + * + * Start of steps summarized by the checkpoint, inclusive + * + * @generated from field: uint32 included_step_index_start = 11; + */ + includedStepIndexStart = 0; + /** + * End of steps summarized by the checkpoint, exclusive + * + * @generated from field: uint32 included_step_index_end = 12; + */ + includedStepIndexEnd = 0; + /** + * Title summarizing the conversation + * + * @generated from field: string conversation_title = 10; + */ + conversationTitle = ''; + /** + * Summary of user's objective and goals + * + * @generated from field: string user_intent = 4; + */ + userIntent = ''; + /** + * Summary of the key context and findings in the included steps + * + * @generated from field: string session_summary = 5; + */ + sessionSummary = ''; + /** + * Summary of code edited and viewed during the included steps + * + * @generated from field: string code_change_summary = 6; + */ + codeChangeSummary = ''; + /** + * Indicates that all model-based summarization attempts failed. + * + * @generated from field: bool model_summarization_failed = 16; + */ + modelSummarizationFailed = false; + /** + * Indicates that a non-model based fallback summary was used + * + * @generated from field: bool used_fallback_summary = 17; + */ + usedFallbackSummary = false; + /** + * Only populated in agentic mode. + * + * @generated from field: repeated exa.cortex_pb.ArtifactSnapshot artifact_snapshots = 14; + */ + artifactSnapshots = []; + /** + * Conversation log URIs + * These are full logs of the entire conversation up to this checkpoint, + * as well as individual logs of each task, if in agentic mode + * + * @generated from field: repeated string conversation_log_uris = 15; + */ + conversationLogUris = []; + /** + * Deprecated + * + * @generated from field: map edited_file_map = 7 [deprecated = true]; + * @deprecated + */ + editedFileMap = {}; + /** + * @generated from field: repeated uint32 included_step_indices = 3 [deprecated = true]; + * @deprecated + */ + includedStepIndices = []; + /** + * @generated from field: string memory_summary = 8 [deprecated = true]; + * @deprecated + */ + memorySummary = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCheckpoint'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'checkpoint_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 9, + name: 'intent_only', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 11, + name: 'included_step_index_start', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 12, + name: 'included_step_index_end', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 10, + name: 'conversation_title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'user_intent', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'session_summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'code_change_summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 16, + name: 'model_summarization_failed', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 17, + name: 'used_fallback_summary', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 14, + name: 'artifact_snapshots', + kind: 'message', + T: ArtifactSnapshot, + repeated: true, + }, + { + no: 15, + name: 'conversation_log_uris', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 7, + name: 'edited_file_map', + kind: 'map', + K: 9, + V: { kind: 'message', T: DiffList }, + }, + { + no: 3, + name: 'included_step_indices', + kind: 'scalar', + T: 13, + repeated: true, + }, + { + no: 8, + name: 'memory_summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCheckpoint().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepCheckpoint().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCheckpoint().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCheckpoint, a, b); + } +}; +var CheckpointConfig = class _CheckpointConfig extends Message { + /** + * Number of new tokens since the last checkpoint before the next checkpoint + * is triggered + * + * @generated from field: uint32 token_threshold = 1; + */ + tokenThreshold = 0; + /** + * The max token ratio of the chat conversation that can be consumed by + * checkpointing summaries + * + * @generated from field: float max_overhead_ratio = 3; + */ + maxOverheadRatio = 0; + /** + * How many checkpoints worth of steps to summarize over when creating a new + * checkpoint + * + * @generated from field: uint32 moving_window_size = 4; + */ + movingWindowSize = 0; + /** + * The max number of tokens that can be in a chat conversation before it will + * be truncated + * + * @generated from field: uint32 max_token_limit = 5; + */ + maxTokenLimit = 0; + /** + * The max output tokens of the checkpoint model + * + * @generated from field: uint32 max_output_tokens = 11; + */ + maxOutputTokens = 0; + /** + * The model used to produce the checkpoint summaries + * + * @generated from field: exa.codeium_common_pb.Model checkpoint_model = 7; + */ + checkpointModel = Model.UNSPECIFIED; + /** + * Whether checkpoint steps are added to the trajectory. Does not affect + * whether trajectories are truncated due to exceeding the max_token_limit. + * + * @generated from field: optional bool enabled = 6; + */ + enabled; + /** + * Whether checkpointing should happen fully async or block the invocation + * until complete. + * + * @generated from field: optional bool full_async = 13; + */ + fullAsync; + /** + * Retry configuration for checkpoint model API calls + * + * @generated from field: exa.cortex_pb.ModelAPIRetryConfig retry_config = 14; + */ + retryConfig; + /** + * If true, a deterministic, non-model based summary will be used as a + * fallback summary if all model requests have failed. + * + * @generated from field: optional bool enable_fallback = 15; + */ + enableFallback; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CheckpointConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'token_threshold', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'max_overhead_ratio', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 4, + name: 'moving_window_size', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'max_token_limit', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 11, + name: 'max_output_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 7, + name: 'checkpoint_model', + kind: 'enum', + T: proto3.getEnumType(Model), + }, + { no: 6, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { no: 13, name: 'full_async', kind: 'scalar', T: 8, opt: true }, + { no: 14, name: 'retry_config', kind: 'message', T: ModelAPIRetryConfig }, + { no: 15, name: 'enable_fallback', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _CheckpointConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CheckpointConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CheckpointConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CheckpointConfig, a, b); + } +}; +var CortexStepMquery = class _CortexStepMquery extends Message { + /** + * TODO(matt): Technically MQuery does not have to ingest the 'plan' input, + * but instead could take in any query on any directories. + * + * @generated from field: exa.cortex_pb.PlanInput input = 1; + */ + input; + /** + * @generated from field: repeated exa.context_module_pb.CciWithSubrangeWithRetrievalMetadata ccis = 2; + */ + ccis = []; + /** + * Progress stats. + * + * @generated from field: uint32 num_tokens_processed = 3; + */ + numTokensProcessed = 0; + /** + * @generated from field: uint32 num_items_scored = 4; + */ + numItemsScored = 0; + /** + * @generated from field: exa.cortex_pb.SemanticCodebaseSearchType search_type = 5; + */ + searchType = SemanticCodebaseSearchType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepMquery'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'input', kind: 'message', T: PlanInput }, + { + no: 2, + name: 'ccis', + kind: 'message', + T: CciWithSubrangeWithRetrievalMetadata, + repeated: true, + }, + { + no: 3, + name: 'num_tokens_processed', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'num_items_scored', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'search_type', + kind: 'enum', + T: proto3.getEnumType(SemanticCodebaseSearchType), + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepMquery().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepMquery().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepMquery().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepMquery, a, b); + } +}; +var ReplacementChunkInfo = class _ReplacementChunkInfo extends Message { + /** + * @generated from field: exa.cortex_pb.ReplacementChunk original_chunk = 1; + */ + originalChunk; + /** + * Empty if exact match is found. + * + * @generated from field: string fuzzy_match = 2; + */ + fuzzyMatch = ''; + /** + * @generated from field: int32 edit_distance = 3; + */ + editDistance = 0; + /** + * @generated from field: float rel_edit_distance = 4; + */ + relEditDistance = 0; + /** + * Uses the fuzzy target. + * + * @generated from field: uint32 num_matches = 5; + */ + numMatches = 0; + /** + * True if the original target was not found in the file. + * + * @generated from field: bool is_non_exact = 7; + */ + isNonExact = false; + /** + * Only populated for non-exact. + * + * @generated from field: bool boundary_lines_match = 8; + */ + boundaryLinesMatch = false; + /** + * @generated from field: bool error = 6; + */ + error = false; + /** + * Only populated if error is true. + * + * @generated from field: string error_str = 9; + */ + errorStr = ''; + /** + * If we will attempt to fix this error with fast apply. + * + * @generated from field: bool fast_apply_fixable = 10; + */ + fastApplyFixable = false; + /** + * If true, uses a global match instead of a local match. + * + * @generated from field: bool use_global_match = 11; + */ + useGlobalMatch = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ReplacementChunkInfo'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'original_chunk', kind: 'message', T: ReplacementChunk }, + { + no: 2, + name: 'fuzzy_match', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'edit_distance', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'rel_edit_distance', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 5, + name: 'num_matches', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 7, + name: 'is_non_exact', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 8, + name: 'boundary_lines_match', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'error', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 9, + name: 'error_str', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'fast_apply_fixable', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 11, + name: 'use_global_match', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _ReplacementChunkInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ReplacementChunkInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ReplacementChunkInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ReplacementChunkInfo, a, b); + } +}; +var FastApplyFallbackInfo = class _FastApplyFallbackInfo extends Message { + /** + * @generated from field: bool fallback_attempted = 1; + */ + fallbackAttempted = false; + /** + * @generated from field: string fallback_error = 2; + */ + fallbackError = ''; + /** + * @generated from field: exa.cortex_pb.ActionResult fast_apply_result = 3; + */ + fastApplyResult; + /** + * @generated from field: exa.cortex_pb.CodeHeuristicFailure heuristic_failure = 4; + */ + heuristicFailure = CodeHeuristicFailure.UNSPECIFIED; + /** + * @generated from field: string fast_apply_prompt = 5; + */ + fastApplyPrompt = ''; + /** + * Number of lines of change that fast apply made outside of the allowed edit + * radius that were masked out. + * + * @generated from field: uint32 num_fast_apply_edits_masked = 6; + */ + numFastApplyEditsMasked = 0; + /** + * True if applying the best match of the fallback targets results in no + * additional diff compared to the base. + * + * @generated from field: bool fallback_match_had_no_diff = 7; + */ + fallbackMatchHadNoDiff = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.FastApplyFallbackInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'fallback_attempted', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'fallback_error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'fast_apply_result', kind: 'message', T: ActionResult }, + { + no: 4, + name: 'heuristic_failure', + kind: 'enum', + T: proto3.getEnumType(CodeHeuristicFailure), + }, + { + no: 5, + name: 'fast_apply_prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'num_fast_apply_edits_masked', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 7, + name: 'fallback_match_had_no_diff', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _FastApplyFallbackInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _FastApplyFallbackInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _FastApplyFallbackInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_FastApplyFallbackInfo, a, b); + } +}; +var CortexStepCodeAction = class _CortexStepCodeAction extends Message { + /** + * @generated from field: exa.cortex_pb.ActionSpec action_spec = 1; + */ + actionSpec; + /** + * @generated from field: exa.cortex_pb.ActionResult action_result = 2; + */ + actionResult; + /** + * @generated from field: bool use_fast_apply = 4; + */ + useFastApply = false; + /** + * The following is only used for Cascade, and indicates that the user has + * reviewed and either accepted or rejected the code changes. + * + * @generated from field: exa.cortex_pb.AcknowledgementType acknowledgement_type = 5; + */ + acknowledgementType = AcknowledgementType.UNSPECIFIED; + /** + * Will be non-zero if the action was not applied due to failing a heuristic. + * + * @generated from field: exa.cortex_pb.CodeHeuristicFailure heuristic_failure = 7; + */ + heuristicFailure = CodeHeuristicFailure.UNSPECIFIED; + /** + * @generated from field: string code_instruction = 8; + */ + codeInstruction = ''; + /** + * @generated from field: string markdown_language = 9; + */ + markdownLanguage = ''; + /** + * New lint errors that were generated while applying the action. + * + * @generated from field: repeated exa.codeium_common_pb.CodeDiagnostic lint_errors = 11; + */ + lintErrors = []; + /** + * Lint errors that were created by a previous step in the same conversation + * but which still exist after this step + * + * @generated from field: repeated exa.codeium_common_pb.CodeDiagnostic persistent_lint_errors = 12; + */ + persistentLintErrors = []; + /** + * Information about each replacement chunk. + * + * @generated from field: repeated exa.cortex_pb.ReplacementChunkInfo replacement_infos = 13; + */ + replacementInfos = []; + /** + * IDs of lint errors that the model was previously notified about that this + * edit aims to fix. + * + * @generated from field: repeated string lint_error_ids_aiming_to_fix = 14; + */ + lintErrorIdsAimingToFix = []; + /** + * Populated if the fast apply fallback was used. + * + * @generated from field: exa.cortex_pb.FastApplyFallbackInfo fast_apply_fallback_info = 15; + */ + fastApplyFallbackInfo; + /** + * If file has any carriage returns. + * + * @generated from field: bool target_file_has_carriage_returns = 16; + */ + targetFileHasCarriageReturns = false; + /** + * If file has all carriage returns. + * + * @generated from field: bool target_file_has_all_carriage_returns = 17; + */ + targetFileHasAllCarriageReturns = false; + /** + * Diagnostics generated by a linting tool (e.g. pylint) after a code action + * step. Only generated and used during eval. + * + * @generated from field: repeated exa.cortex_pb.CortexStepCompileDiagnostic introduced_errors = 18 [deprecated = true]; + * @deprecated + */ + introducedErrors = []; + /** + * Rules that were triggered by this code action step. + * TODO(sean): This is currently pattern matched to the triggered memories in + * the view file tools, but probably should be a list of CortexMemory. + * + * @generated from field: string triggered_memories = 19; + */ + triggeredMemories = ''; + /** + * True if the code action is on an artifact file. + * + * @generated from field: bool is_artifact_file = 21; + */ + isArtifactFile = false; + /** + * The version of the artifact file that was created by this step. Only + * applicable if is_artifact_file is true. May be -1 if the artifact type + * does not support versioning. + * + * @generated from field: int32 artifact_version = 22; + */ + artifactVersion = 0; + /** + * Metadata about the artifact file that was updated by this step. Only + * applicable if is_artifact_file is true. + * + * @generated from field: exa.codeium_common_pb.ArtifactMetadata artifact_metadata = 23; + */ + artifactMetadata; + /** + * True if the code action is on a knowledge item. + * + * @generated from field: bool is_knowledge_file = 24; + */ + isKnowledgeFile = false; + /** + * @generated from field: exa.cortex_pb.FilePermissionInteractionSpec file_permission_request = 25; + */ + filePermissionRequest; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCodeAction'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'action_spec', kind: 'message', T: ActionSpec }, + { no: 2, name: 'action_result', kind: 'message', T: ActionResult }, + { + no: 4, + name: 'use_fast_apply', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'acknowledgement_type', + kind: 'enum', + T: proto3.getEnumType(AcknowledgementType), + }, + { + no: 7, + name: 'heuristic_failure', + kind: 'enum', + T: proto3.getEnumType(CodeHeuristicFailure), + }, + { + no: 8, + name: 'code_instruction', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'markdown_language', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 11, + name: 'lint_errors', + kind: 'message', + T: CodeDiagnostic, + repeated: true, + }, + { + no: 12, + name: 'persistent_lint_errors', + kind: 'message', + T: CodeDiagnostic, + repeated: true, + }, + { + no: 13, + name: 'replacement_infos', + kind: 'message', + T: ReplacementChunkInfo, + repeated: true, + }, + { + no: 14, + name: 'lint_error_ids_aiming_to_fix', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 15, + name: 'fast_apply_fallback_info', + kind: 'message', + T: FastApplyFallbackInfo, + }, + { + no: 16, + name: 'target_file_has_carriage_returns', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 17, + name: 'target_file_has_all_carriage_returns', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 18, + name: 'introduced_errors', + kind: 'message', + T: CortexStepCompileDiagnostic, + repeated: true, + }, + { + no: 19, + name: 'triggered_memories', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 21, + name: 'is_artifact_file', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 22, + name: 'artifact_version', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { no: 23, name: 'artifact_metadata', kind: 'message', T: ArtifactMetadata }, + { + no: 24, + name: 'is_knowledge_file', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 25, + name: 'file_permission_request', + kind: 'message', + T: FilePermissionInteractionSpec, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCodeAction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepCodeAction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCodeAction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCodeAction, a, b); + } +}; +var CortexStepFileChange = class _CortexStepFileChange extends Message { + /** + * The absolute path to the changed file. + * + * @generated from field: string absolute_path_uri = 1; + */ + absolutePathUri = ''; + /** + * The type of file change. + * + * @generated from field: exa.cortex_pb.FileChangeType file_change_type = 2; + */ + fileChangeType = FileChangeType.UNSPECIFIED; + /** + * The replacement chunks applied to the file. For file creation, this should + * have a single replacement chunk with an empty TargetContent and the entire + * file content as the ReplacementContent. For file deletion, this should be + * empty. + * + * @generated from field: repeated exa.cortex_pb.ReplacementChunk replacement_chunks = 3; + */ + replacementChunks = []; + /** + * A description of the changes made to the file, populated by the model. + * + * @generated from field: string instruction = 5; + */ + instruction = ''; + /** + * The diff applied to the file. + * + * @generated from field: exa.diff_action_pb.DiffBlock diff = 4; + */ + diff; + /** + * Information about each replacement chunk. + * + * @generated from field: repeated exa.cortex_pb.ReplacementChunkInfo replacement_infos = 6; + */ + replacementInfos = []; + /** + * Populated if the fast apply fallback was used. + * + * @generated from field: exa.cortex_pb.FastApplyFallbackInfo fast_apply_fallback_info = 7; + */ + fastApplyFallbackInfo; + /** + * If true, allow overwriting an existing file during file creation. + * + * @generated from field: bool overwrite = 8; + */ + overwrite = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepFileChange'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'file_change_type', + kind: 'enum', + T: proto3.getEnumType(FileChangeType), + }, + { + no: 3, + name: 'replacement_chunks', + kind: 'message', + T: ReplacementChunk, + repeated: true, + }, + { + no: 5, + name: 'instruction', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'diff', kind: 'message', T: DiffBlock }, + { + no: 6, + name: 'replacement_infos', + kind: 'message', + T: ReplacementChunkInfo, + repeated: true, + }, + { + no: 7, + name: 'fast_apply_fallback_info', + kind: 'message', + T: FastApplyFallbackInfo, + }, + { + no: 8, + name: 'overwrite', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepFileChange().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepFileChange().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepFileChange().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepFileChange, a, b); + } +}; +var CortexStepMove = class _CortexStepMove extends Message { + /** + * The absolute path to the source file or directory to move. + * + * @generated from field: string src_absolute_path_uri = 1; + */ + srcAbsolutePathUri = ''; + /** + * The absolute path to the destination location. + * + * @generated from field: string dst_absolute_path_uri = 2; + */ + dstAbsolutePathUri = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepMove'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'src_absolute_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'dst_absolute_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepMove().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepMove().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepMove().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepMove, a, b); + } +}; +var CortexStepEphemeralMessage = class _CortexStepEphemeralMessage extends Message { + /** + * The ephemeral message shown to the model. + * + * @generated from field: string content = 1; + */ + content = ''; + /** + * Optional media (ex. images) included with the message. + * + * @generated from field: repeated exa.codeium_common_pb.Media media = 2; + */ + media = []; + /** + * The heuristics that were triggered to generate this message. + * + * @generated from field: repeated string triggered_heuristics = 3; + */ + triggeredHeuristics = []; + /** + * Dummy field named attachments to allow old clients sending protojson to + * still get parsed correctly by the CCPA server. If the server receives + * a message with attachments, it will convert it to the media field. + * + * @generated from field: repeated exa.codeium_common_pb.Media attachments = 4; + */ + attachments = []; + /** + * The DOM tree of the current page. + * + * @generated from field: string dom_tree_uri = 5; + */ + domTreeUri = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepEphemeralMessage'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'media', kind: 'message', T: Media, repeated: true }, + { + no: 3, + name: 'triggered_heuristics', + kind: 'scalar', + T: 9, + repeated: true, + }, + { no: 4, name: 'attachments', kind: 'message', T: Media, repeated: true }, + { + no: 5, + name: 'dom_tree_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepEphemeralMessage().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepEphemeralMessage().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepEphemeralMessage().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepEphemeralMessage, a, b); + } +}; +var CortexStepConversationHistory = class _CortexStepConversationHistory extends Message { + /** + * The formatted conversation history content. + * + * @generated from field: string content = 1; + */ + content = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepConversationHistory'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepConversationHistory().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepConversationHistory().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepConversationHistory().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepConversationHistory, a, b); + } +}; +var CortexStepKnowledgeArtifacts = class _CortexStepKnowledgeArtifacts extends Message { + /** + * The formatted knowledge artifacts content. + * + * @generated from field: string content = 1; + */ + content = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepKnowledgeArtifacts'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepKnowledgeArtifacts().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepKnowledgeArtifacts().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepKnowledgeArtifacts().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepKnowledgeArtifacts, a, b); + } +}; +var CortexStepProposeCode = class _CortexStepProposeCode extends Message { + /** + * @generated from field: exa.cortex_pb.ActionSpec action_spec = 1; + */ + actionSpec; + /** + * @generated from field: exa.cortex_pb.ActionResult action_result = 2; + */ + actionResult; + /** + * Shown to the user as a preview of the proposed changes. + * + * @generated from field: string code_instruction = 3; + */ + codeInstruction = ''; + /** + * @generated from field: string markdown_language = 4; + */ + markdownLanguage = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepProposeCode'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'action_spec', kind: 'message', T: ActionSpec }, + { no: 2, name: 'action_result', kind: 'message', T: ActionResult }, + { + no: 3, + name: 'code_instruction', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'markdown_language', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepProposeCode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepProposeCode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepProposeCode().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepProposeCode, a, b); + } +}; +var CortexStepGitCommit = class _CortexStepGitCommit extends Message { + /** + * TODO(matt): Reconsider if this belongs here. + * + * @generated from field: exa.cortex_pb.PlanInput input = 1; + */ + input; + /** + * @generated from field: string commit_message = 2; + */ + commitMessage = ''; + /** + * @generated from field: string commit_hash = 3; + */ + commitHash = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepGitCommit'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'input', kind: 'message', T: PlanInput }, + { + no: 2, + name: 'commit_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'commit_hash', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepGitCommit().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepGitCommit().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepGitCommit().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepGitCommit, a, b); + } +}; +var GrepSearchResult = class _GrepSearchResult extends Message { + /** + * @generated from field: string relative_path = 1; + */ + relativePath = ''; + /** + * 0-indexed + * + * @generated from field: uint32 line_number = 2; + */ + lineNumber = 0; + /** + * @generated from field: string content = 3; + */ + content = ''; + /** + * @generated from field: string absolute_path = 4; + */ + absolutePath = ''; + /** + * @generated from field: exa.codeium_common_pb.CodeContextItem cci = 5; + */ + cci; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.GrepSearchResult'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'relative_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'line_number', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'absolute_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'cci', kind: 'message', T: CodeContextItem }, + ]); + static fromBinary(bytes, options) { + return new _GrepSearchResult().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GrepSearchResult().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GrepSearchResult().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GrepSearchResult, a, b); + } +}; +var DiffBasedCommandEvalConfig = class _DiffBasedCommandEvalConfig extends Message { + /** + * @generated from field: uint32 num_samples_per_commit = 1; + */ + numSamplesPerCommit = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.DiffBasedCommandEvalConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'num_samples_per_commit', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _DiffBasedCommandEvalConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _DiffBasedCommandEvalConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _DiffBasedCommandEvalConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_DiffBasedCommandEvalConfig, a, b); + } +}; +var CortexStepGrepSearch = class _CortexStepGrepSearch extends Message { + /** + * Inputs + * + * Uri to run the grep command from. + * + * @generated from field: string search_path_uri = 11; + */ + searchPathUri = ''; + /** + * @generated from field: string query = 1; + */ + query = ''; + /** + * @generated from field: bool match_per_line = 8; + */ + matchPerLine = false; + /** + * @generated from field: repeated string includes = 2; + */ + includes = []; + /** + * New field for case-insensitive search + * + * @generated from field: bool case_insensitive = 9; + */ + caseInsensitive = false; + /** + * Whether to allow ripgrep to match files in .gitignore + * + * @generated from field: bool allow_access_gitignore = 13; + */ + allowAccessGitignore = false; + /** + * If true, then treat the query as a regexp + * + * @generated from field: bool is_regex = 14; + */ + isRegex = false; + /** + * Outputs. + * + * @generated from field: repeated exa.cortex_pb.GrepSearchResult results = 4; + */ + results = []; + /** + * Will not be modified when truncated. + * + * @generated from field: uint32 total_results = 7; + */ + totalResults = 0; + /** + * Primarily for debug, will not be truncated. + * + * @generated from field: string raw_output = 3; + */ + rawOutput = ''; + /** + * The command that was run. + * + * @generated from field: string command_run = 10; + */ + commandRun = ''; + /** + * Indicates no files were searched + * + * @generated from field: bool no_files_searched = 12; + */ + noFilesSearched = false; + /** + * Indicates whether the grep command timed out + * + * @generated from field: bool timed_out = 15; + */ + timedOut = false; + /** + * @generated from field: exa.cortex_pb.FilePermissionInteractionSpec file_permission_request = 16; + */ + filePermissionRequest; + /** + * Error when running the grep command. + * + * @generated from field: string grep_error = 5 [deprecated = true]; + * @deprecated + */ + grepError = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepGrepSearch'; + static fields = proto3.util.newFieldList(() => [ + { + no: 11, + name: 'search_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'match_per_line', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 2, name: 'includes', kind: 'scalar', T: 9, repeated: true }, + { + no: 9, + name: 'case_insensitive', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 13, + name: 'allow_access_gitignore', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 14, + name: 'is_regex', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'results', + kind: 'message', + T: GrepSearchResult, + repeated: true, + }, + { + no: 7, + name: 'total_results', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'raw_output', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'command_run', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'no_files_searched', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 15, + name: 'timed_out', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 16, + name: 'file_permission_request', + kind: 'message', + T: FilePermissionInteractionSpec, + }, + { + no: 5, + name: 'grep_error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepGrepSearch().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepGrepSearch().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepGrepSearch().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepGrepSearch, a, b); + } +}; +var CortexStepFind = class _CortexStepFind extends Message { + /** + * Inputs. + * + * directory to run the fd command from. + * + * @generated from field: string search_directory = 10; + */ + searchDirectory = ''; + /** + * the search pattern (supports regex) + * + * @generated from field: string pattern = 1; + */ + pattern = ''; + /** + * glob patterns to exclude + * + * @generated from field: repeated string excludes = 3; + */ + excludes = []; + /** + * type (file or directory) + * + * @generated from field: exa.cortex_pb.FindResultType type = 4; + */ + type = FindResultType.UNSPECIFIED; + /** + * maximum depth to search (<= 0 for unlimited) + * + * @generated from field: int32 max_depth = 5; + */ + maxDepth = 0; + /** + * file extensions to include (e.g., "go", "py") + * + * @generated from field: repeated string extensions = 12; + */ + extensions = []; + /** + * whether to search the full absolute path, default: filename only + * + * @generated from field: bool full_path = 13; + */ + fullPath = false; + /** + * Outputs. + * + * Potentially truncated version of raw_output shown to model. + * + * @generated from field: string truncated_output = 14; + */ + truncatedOutput = ''; + /** + * Number of truncated results. + * + * @generated from field: uint32 truncated_total_results = 15; + */ + truncatedTotalResults = 0; + /** + * Number of untruncated results. + * + * @generated from field: uint32 total_results = 7; + */ + totalResults = 0; + /** + * Primarily for debug, will not be truncated. + * + * @generated from field: string raw_output = 11; + */ + rawOutput = ''; + /** + * The command that was run. + * + * @generated from field: string command_run = 9; + */ + commandRun = ''; + /** + * Deprecated fields. + * + * @generated from field: repeated string includes = 2 [deprecated = true]; + * @deprecated + */ + includes = []; + /** + * Error when running the find command. + * + * @generated from field: string find_error = 8 [deprecated = true]; + * @deprecated + */ + findError = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepFind'; + static fields = proto3.util.newFieldList(() => [ + { + no: 10, + name: 'search_directory', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 1, + name: 'pattern', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'excludes', kind: 'scalar', T: 9, repeated: true }, + { + no: 4, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(FindResultType), + }, + { + no: 5, + name: 'max_depth', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { no: 12, name: 'extensions', kind: 'scalar', T: 9, repeated: true }, + { + no: 13, + name: 'full_path', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 14, + name: 'truncated_output', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 15, + name: 'truncated_total_results', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 7, + name: 'total_results', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 11, + name: 'raw_output', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'command_run', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'includes', kind: 'scalar', T: 9, repeated: true }, + { + no: 8, + name: 'find_error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepFind().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepFind().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepFind().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepFind, a, b); + } +}; +var CortexStepViewFile = class _CortexStepViewFile extends Message { + /** + * @generated from field: string absolute_path_uri = 1; + */ + absolutePathUri = ''; + /** + * 0-indexed, inclusive + * + * @generated from field: uint32 start_line = 2; + */ + startLine = 0; + /** + * 0-indexed, inclusive + * + * @generated from field: uint32 end_line = 3; + */ + endLine = 0; + /** + * @generated from field: string content = 4; + */ + content = ''; + /** + * Full raw content of the file. + * + * @generated from field: string raw_content = 9; + */ + rawContent = ''; + /** + * Deprecated use media_data + * + * @generated from field: exa.codeium_common_pb.ImageData binary_data = 14 [deprecated = true]; + * @deprecated + */ + binaryData; + /** + * Populated only when viewing a binary file, contains the entire file + * content. + * + * @generated from field: exa.codeium_common_pb.Media media_data = 15; + */ + mediaData; + /** + * Any rules that were triggered by this file view. + * + * @generated from field: string triggered_memories = 10; + */ + triggeredMemories = ''; + /** + * The total number of lines in the file. + * + * @generated from field: uint32 num_lines = 11; + */ + numLines = 0; + /** + * The total number of bytes in the file. + * + * @generated from field: uint32 num_bytes = 12; + */ + numBytes = 0; + /** + * If true, this view file step was injected as a reminder. + * + * @generated from field: bool is_injected_reminder = 13; + */ + isInjectedReminder = false; + /** + * @generated from field: exa.cortex_pb.FilePermissionInteractionSpec file_permission_request = 16; + */ + filePermissionRequest; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepViewFile'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'start_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'end_line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'raw_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 14, name: 'binary_data', kind: 'message', T: ImageData }, + { no: 15, name: 'media_data', kind: 'message', T: Media }, + { + no: 10, + name: 'triggered_memories', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 11, + name: 'num_lines', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 12, + name: 'num_bytes', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 13, + name: 'is_injected_reminder', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 16, + name: 'file_permission_request', + kind: 'message', + T: FilePermissionInteractionSpec, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepViewFile().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepViewFile().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepViewFile().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepViewFile, a, b); + } +}; +var ListDirectoryResult = class _ListDirectoryResult extends Message { + /** + * @generated from field: string name = 1; + */ + name = ''; + /** + * @generated from field: bool is_dir = 2; + */ + isDir = false; + /** + * Recursive count, only set if is_dir is true. May be nil for a directory if + * the workspace manager has not fully scanned the directory + * + * @generated from field: optional uint32 num_children = 3; + */ + numChildren; + /** + * Only set if is_dir is false + * + * @generated from field: uint64 size_bytes = 4; + */ + sizeBytes = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ListDirectoryResult'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'is_dir', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 3, name: 'num_children', kind: 'scalar', T: 13, opt: true }, + { + no: 4, + name: 'size_bytes', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ListDirectoryResult().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ListDirectoryResult().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ListDirectoryResult().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ListDirectoryResult, a, b); + } +}; +var CortexStepListDirectory = class _CortexStepListDirectory extends Message { + /** + * @generated from field: string directory_path_uri = 1; + */ + directoryPathUri = ''; + /** + * Children are relative to the directory. + * + * @generated from field: repeated string children = 2 [deprecated = true]; + * @deprecated + */ + children = []; + /** + * @generated from field: repeated exa.cortex_pb.ListDirectoryResult results = 3; + */ + results = []; + /** + * @generated from field: bool dir_not_found = 4 [deprecated = true]; + * @deprecated + */ + dirNotFound = false; + /** + * @generated from field: exa.cortex_pb.FilePermissionInteractionSpec file_permission_request = 5; + */ + filePermissionRequest; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepListDirectory'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'directory_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'children', kind: 'scalar', T: 9, repeated: true }, + { + no: 3, + name: 'results', + kind: 'message', + T: ListDirectoryResult, + repeated: true, + }, + { + no: 4, + name: 'dir_not_found', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'file_permission_request', + kind: 'message', + T: FilePermissionInteractionSpec, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepListDirectory().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepListDirectory().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepListDirectory().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepListDirectory, a, b); + } +}; +var CortexStepDeleteDirectory = class _CortexStepDeleteDirectory extends Message { + /** + * @generated from field: string directory_path_uri = 1; + */ + directoryPathUri = ''; + /** + * If true, recursively delete all files and subdirectories + * If false, only delete empty directories, + * and error if the directory is not empty + * + * @generated from field: bool force = 2; + */ + force = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepDeleteDirectory'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'directory_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'force', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepDeleteDirectory().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepDeleteDirectory().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepDeleteDirectory().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepDeleteDirectory, a, b); + } +}; +var CortexStepCompileDiagnostic = class _CortexStepCompileDiagnostic extends Message { + /** + * @generated from field: string message = 1; + */ + message = ''; + /** + * @generated from field: string path = 2; + */ + path = ''; + /** + * @generated from field: uint32 line = 3; + */ + line = 0; + /** + * @generated from field: uint32 column = 4; + */ + column = 0; + /** + * The symbol indicates the type of error or warning encountered + * by the linter e.g. syntax-error, unused, import, type + * + * @generated from field: string symbol = 5; + */ + symbol = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCompileDiagnostic'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'column', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'symbol', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCompileDiagnostic().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepCompileDiagnostic().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCompileDiagnostic().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCompileDiagnostic, a, b); + } +}; +var CortexStepCompile = class _CortexStepCompile extends Message { + /** + * @generated from field: exa.cortex_pb.CortexStepCompileTool tool = 1; + */ + tool = CortexStepCompileTool.UNSPECIFIED; + /** + * The input to compile. This can be a file/directory path or something else + * specific to the compile tool (eg. Bazel label). The handler will internally + * infer a build target based on the input. + * + * @generated from field: string input_spec = 2; + */ + inputSpec = ''; + /** + * The compilation tools can take various options to customize their behavior. + * However, running compile without options should work on most codebases. + * + * @generated from field: map options = 3; + */ + options = {}; + /** + * The name of the inferred build target. + * + * @generated from field: string target = 4; + */ + target = ''; + /** + * The path to the actual build artifact, if any. + * + * @generated from field: string artifact_path = 5; + */ + artifactPath = ''; + /** + * Whether the build target is an executable. + * + * @generated from field: bool artifact_is_executable = 6; + */ + artifactIsExecutable = false; + /** + * @generated from field: repeated exa.cortex_pb.CortexStepCompileDiagnostic errors = 7; + */ + errors = []; + /** + * @generated from field: repeated exa.cortex_pb.CortexStepCompileDiagnostic warnings = 8; + */ + warnings = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCompile'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'tool', + kind: 'enum', + T: proto3.getEnumType(CortexStepCompileTool), + }, + { + no: 2, + name: 'input_spec', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'options', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { + no: 4, + name: 'target', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'artifact_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'artifact_is_executable', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'errors', + kind: 'message', + T: CortexStepCompileDiagnostic, + repeated: true, + }, + { + no: 8, + name: 'warnings', + kind: 'message', + T: CortexStepCompileDiagnostic, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCompile().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepCompile().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCompile().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCompile, a, b); + } +}; +var CortexStepCompileApplet = class _CortexStepCompileApplet extends Message { + /** + * Error message from the build, if any. + * + * @generated from field: string error_message = 1; + */ + errorMessage = ''; + /** + * Build logs, populated when build fails. + * + * @generated from field: string logs = 3; + */ + logs = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCompileApplet'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'logs', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCompileApplet().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepCompileApplet().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCompileApplet().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCompileApplet, a, b); + } +}; +var CortexStepInstallAppletDependencies = class _CortexStepInstallAppletDependencies extends Message { + /** + * Error message from the install, if any. + * + * @generated from field: string error_message = 1; + */ + errorMessage = ''; + /** + * Logs from the install. + * + * @generated from field: string logs = 2; + */ + logs = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepInstallAppletDependencies'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'logs', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepInstallAppletDependencies().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CortexStepInstallAppletDependencies().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CortexStepInstallAppletDependencies().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepInstallAppletDependencies, a, b); + } +}; +var CortexStepInstallAppletPackage = class _CortexStepInstallAppletPackage extends Message { + /** + * The package name to install. + * + * @generated from field: string package_name = 1 [deprecated = true]; + * @deprecated + */ + packageName = ''; + /** + * Error message from the install, if any. + * + * @generated from field: string error_message = 2; + */ + errorMessage = ''; + /** + * Logs from the install. + * + * @generated from field: string logs = 3; + */ + logs = ''; + /** + * Whether the packages are dev dependencies. + * + * @generated from field: bool is_dev_dependency = 4; + */ + isDevDependency = false; + /** + * The package names to install. + * + * @generated from field: repeated string package_names = 5; + */ + packageNames = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepInstallAppletPackage'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'package_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'logs', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'is_dev_dependency', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 5, name: 'package_names', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepInstallAppletPackage().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepInstallAppletPackage().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepInstallAppletPackage().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepInstallAppletPackage, a, b); + } +}; +var CortexStepSetUpFirebase = class _CortexStepSetUpFirebase extends Message { + /** + * Error message from the setup, if any. + * + * @generated from field: string error_message = 1; + */ + errorMessage = ''; + /** + * Error code from the setup, if any. These codes are canonical error codes + * (see: go/canonical-codes) that map to google3/google/rpc/code.proto + * + * @generated from field: exa.cortex_pb.SetUpFirebaseErrorCode rpc_error_code = 6; + */ + rpcErrorCode = SetUpFirebaseErrorCode.ERROR_CODE_OK; + /** + * Optional Firebase project ID to use for the app, instead of the default + * Cloud project used in AI Studio. + * + * @generated from field: optional string firebase_project_id = 7; + */ + firebaseProjectId; + /** + * The requested action from the agent or user for what the tool should do + * + * @generated from field: exa.cortex_pb.SetUpFirebaseRequest request = 2; + */ + request = SetUpFirebaseRequest.UNSPECIFIED; + /** + * The result of the tool setup, indicating how the frontend should proceed. + * + * @generated from field: exa.cortex_pb.SetUpFirebaseResult result = 3; + */ + result = SetUpFirebaseResult.UNSPECIFIED; + /** + * The app config that was provisioned by the tool. + * + * @generated from field: exa.cortex_pb.SetUpFirebaseAppConfig app_config = 4; + */ + appConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepSetUpFirebase'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'rpc_error_code', + kind: 'enum', + T: proto3.getEnumType(SetUpFirebaseErrorCode), + }, + { no: 7, name: 'firebase_project_id', kind: 'scalar', T: 9, opt: true }, + { + no: 2, + name: 'request', + kind: 'enum', + T: proto3.getEnumType(SetUpFirebaseRequest), + }, + { + no: 3, + name: 'result', + kind: 'enum', + T: proto3.getEnumType(SetUpFirebaseResult), + }, + { no: 4, name: 'app_config', kind: 'message', T: SetUpFirebaseAppConfig }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepSetUpFirebase().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepSetUpFirebase().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepSetUpFirebase().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepSetUpFirebase, a, b); + } +}; +var SetUpFirebaseAppConfig = class _SetUpFirebaseAppConfig extends Message { + /** + * The Firebase project id for the app. + * + * @generated from field: string firebase_project_id = 1; + */ + firebaseProjectId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.SetUpFirebaseAppConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'firebase_project_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _SetUpFirebaseAppConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SetUpFirebaseAppConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SetUpFirebaseAppConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SetUpFirebaseAppConfig, a, b); + } +}; +var CortexStepRestartDevServer = class _CortexStepRestartDevServer extends Message { + /** + * Error message from the restart, if any. + * + * @generated from field: string error_message = 1; + */ + errorMessage = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepRestartDevServer'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepRestartDevServer().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepRestartDevServer().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepRestartDevServer().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepRestartDevServer, a, b); + } +}; +var CortexStepDeployFirebase = class _CortexStepDeployFirebase extends Message { + /** + * Error message from the deploy, if any. + * + * @generated from field: string error_message = 1; + */ + errorMessage = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepDeployFirebase'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepDeployFirebase().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepDeployFirebase().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepDeployFirebase().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepDeployFirebase, a, b); + } +}; +var CortexStepShellExec = class _CortexStepShellExec extends Message { + /** + * The command to execute. + * + * @generated from field: string command = 1; + */ + command = ''; + /** + * The exit code of the command. + * + * @generated from field: int32 exit_code = 2; + */ + exitCode = 0; + /** + * The output of the command (stdout and stderr combined). + * + * @generated from field: string output = 3; + */ + output = ''; + /** + * Error message from the execution, if any. + * + * @generated from field: string error_message = 4; + */ + errorMessage = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepShellExec'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'command', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'exit_code', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'output', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepShellExec().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepShellExec().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepShellExec().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepShellExec, a, b); + } +}; +var CortexStepLintApplet = class _CortexStepLintApplet extends Message { + /** + * The exit code of the linter. + * + * @generated from field: int32 exit_code = 1; + */ + exitCode = 0; + /** + * The output of the linter. + * + * @generated from field: string output = 2; + */ + output = ''; + /** + * Error message from the linter, if any. + * + * @generated from field: string error_message = 3; + */ + errorMessage = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepLintApplet'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'exit_code', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 2, + name: 'output', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepLintApplet().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepLintApplet().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepLintApplet().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepLintApplet, a, b); + } +}; +var CortexStepDefineNewEnvVariable = class _CortexStepDefineNewEnvVariable extends Message { + /** + * The environment variable name detected (e.g., "NEXT_PUBLIC_API_KEY") + * + * @generated from field: string variable_name = 1; + */ + variableName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepDefineNewEnvVariable'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'variable_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepDefineNewEnvVariable().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepDefineNewEnvVariable().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepDefineNewEnvVariable().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepDefineNewEnvVariable, a, b); + } +}; +var CortexStepWriteBlob = class _CortexStepWriteBlob extends Message { + /** + * Input: The blob_id. + * + * @generated from field: string blob_id = 1; + */ + blobId = ''; + /** + * Input: The target path in the applet filesystem. + * + * @generated from field: string target_path = 2; + */ + targetPath = ''; + /** + * Output: Error message if the operation failed. + * + * @generated from field: string error_message = 3; + */ + errorMessage = ''; + /** + * Output: The number of bytes written. + * + * @generated from field: int64 bytes_written = 4; + */ + bytesWritten = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepWriteBlob'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'blob_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'target_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'error_message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'bytes_written', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepWriteBlob().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepWriteBlob().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepWriteBlob().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepWriteBlob, a, b); + } +}; +var CortexTrajectoryToPromptConfig = class _CortexTrajectoryToPromptConfig extends Message { + /** + * The fraction of the system prompt to allocate to the trajectory. + * + * @generated from field: float prompt_fraction = 1; + */ + promptFraction = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexTrajectoryToPromptConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'prompt_fraction', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexTrajectoryToPromptConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexTrajectoryToPromptConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexTrajectoryToPromptConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexTrajectoryToPromptConfig, a, b); + } +}; +var CortexStepUserInput = class _CortexStepUserInput extends Message { + /** + * @generated from field: repeated exa.codeium_common_pb.TextOrScopeItem items = 3; + */ + items = []; + /** + * items converted to readable string. + * + * @generated from field: string user_response = 2; + */ + userResponse = ''; + /** + * Only contains active doc, local node state, and open docs. Content of the + * docs will be cleared to save memory. + * + * @generated from field: exa.context_module_pb.ContextModuleResult active_user_state = 4; + */ + activeUserState; + /** + * Artifact comments are sent along with the user input. + * + * @generated from field: repeated exa.codeium_common_pb.ArtifactComment artifact_comments = 7; + */ + artifactComments = []; + /** + * File diff comments are sent along with the user input. + * + * @generated from field: repeated exa.codeium_common_pb.FileDiffComment file_diff_comments = 10; + */ + fileDiffComments = []; + /** + * File comments are sent along with the user input. + * + * @generated from field: repeated exa.codeium_common_pb.FileComment file_comments = 11; + */ + fileComments = []; + /** + * Whether the message was sent mid-stream as a queued message. + * + * @generated from field: bool is_queued_message = 6; + */ + isQueuedMessage = false; + /** + * What type of chat client panel this message is from (IDE panel, browser + * panel, etc.) + * + * @generated from field: exa.chat_client_server_pb.ChatClientRequestStreamClientType client_type = 8; + */ + clientType = ChatClientRequestStreamClientType.UNSPECIFIED; + /** + * NOTE: This is not the fully resolved config, just the subset of the config + * specified by the user directly. + * + * @generated from field: exa.cortex_pb.CascadeConfig user_config = 12; + */ + userConfig; + /** + * Same as above, but from the last user input. Nil if there is no last user + * input. + * + * @generated from field: exa.cortex_pb.CascadeConfig last_user_config = 13; + */ + lastUserConfig; + /** + * DEPRECATED + * + * @generated from field: string query = 1 [deprecated = true]; + * @deprecated + */ + query = ''; + /** + * Deprecated: Use media instead + * + * @generated from field: repeated exa.codeium_common_pb.ImageData images = 5 [deprecated = true]; + * @deprecated + */ + images = []; + /** + * Arbitrary file media as part of the user input. + * Supported types include text files, images, and PDFs. + * + * @generated from field: repeated exa.codeium_common_pb.Media media = 9; + */ + media = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepUserInput'; + static fields = proto3.util.newFieldList(() => [ + { + no: 3, + name: 'items', + kind: 'message', + T: TextOrScopeItem, + repeated: true, + }, + { + no: 2, + name: 'user_response', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'active_user_state', + kind: 'message', + T: ContextModuleResult, + }, + { + no: 7, + name: 'artifact_comments', + kind: 'message', + T: ArtifactComment, + repeated: true, + }, + { + no: 10, + name: 'file_diff_comments', + kind: 'message', + T: FileDiffComment, + repeated: true, + }, + { + no: 11, + name: 'file_comments', + kind: 'message', + T: FileComment, + repeated: true, + }, + { + no: 6, + name: 'is_queued_message', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 8, + name: 'client_type', + kind: 'enum', + T: proto3.getEnumType(ChatClientRequestStreamClientType), + }, + { no: 12, name: 'user_config', kind: 'message', T: CascadeConfig }, + { no: 13, name: 'last_user_config', kind: 'message', T: CascadeConfig }, + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'images', kind: 'message', T: ImageData, repeated: true }, + { no: 9, name: 'media', kind: 'message', T: Media, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepUserInput().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepUserInput().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepUserInput().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepUserInput, a, b); + } +}; +var ActiveUserState = class _ActiveUserState extends Message { + /** + * @generated from field: exa.codeium_common_pb.Document active_document = 1; + */ + activeDocument; + /** + * @generated from field: repeated exa.codeium_common_pb.Document open_documents = 2; + */ + openDocuments = []; + /** + * @generated from field: exa.codeium_common_pb.CodeContextItem active_node = 3; + */ + activeNode; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ActiveUserState'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'active_document', kind: 'message', T: Document }, + { + no: 2, + name: 'open_documents', + kind: 'message', + T: Document, + repeated: true, + }, + { no: 3, name: 'active_node', kind: 'message', T: CodeContextItem }, + ]); + static fromBinary(bytes, options) { + return new _ActiveUserState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ActiveUserState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ActiveUserState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ActiveUserState, a, b); + } +}; +var CortexStepPlannerResponse = class _CortexStepPlannerResponse extends Message { + /** + * This is the direct raw output from the planner. + * User-facing clients should not handle this field directly (and should + * not expect it to necessarily be populated in the proto it receives). + * + * @generated from field: string response = 1; + */ + response = ''; + /** + * We may modify the response to include additional information, such as + * citations. This is what should be handled by the client. + * + * @generated from field: string modified_response = 8; + */ + modifiedResponse = ''; + /** + * @generated from field: string thinking = 3; + */ + thinking = ''; + /** + * Deprecated. Use thinking_signature instead. + * + * @generated from field: string signature = 4 [deprecated = true]; + * @deprecated + */ + signature = ''; + /** + * @generated from field: bytes thinking_signature = 14; + */ + thinkingSignature = new Uint8Array(0); + /** + * @generated from field: bool thinking_redacted = 5; + */ + thinkingRedacted = false; + /** + * @generated from field: string message_id = 6; + */ + messageId = ''; + /** + * All tool calls generated by the planner in this response. + * + * @generated from field: repeated exa.codeium_common_pb.ChatToolCall tool_calls = 7; + */ + toolCalls = []; + /** + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseItemWithMetadata knowledge_base_items = 2; + */ + knowledgeBaseItems = []; + /** + * @generated from field: google.protobuf.Duration thinking_duration = 11; + */ + thinkingDuration; + /** + * @generated from field: exa.codeium_common_pb.StopReason stop_reason = 12; + */ + stopReason = StopReason.UNSPECIFIED; + /** + * Citation metadata aggregated from model response stream + * + * @generated from field: exa.codeium_common_pb.RecitationMetadata recitation_metadata = 13; + */ + recitationMetadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepPlannerResponse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'response', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'modified_response', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'thinking', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'signature', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 14, + name: 'thinking_signature', + kind: 'scalar', + T: 12, + /* ScalarType.BYTES */ + }, + { + no: 5, + name: 'thinking_redacted', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'message_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'tool_calls', + kind: 'message', + T: ChatToolCall, + repeated: true, + }, + { + no: 2, + name: 'knowledge_base_items', + kind: 'message', + T: KnowledgeBaseItemWithMetadata, + repeated: true, + }, + { no: 11, name: 'thinking_duration', kind: 'message', T: Duration }, + { + no: 12, + name: 'stop_reason', + kind: 'enum', + T: proto3.getEnumType(StopReason), + }, + { + no: 13, + name: 'recitation_metadata', + kind: 'message', + T: RecitationMetadata, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepPlannerResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepPlannerResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepPlannerResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepPlannerResponse, a, b); + } +}; +var CortexStepFileBreakdown = class _CortexStepFileBreakdown extends Message { + /** + * INPUTS + * + * @generated from field: string absolute_path = 1; + */ + absolutePath = ''; + /** + * Only one of the following should be populated. + * + * @generated from field: exa.codeium_common_pb.DocumentOutline document_outline = 2; + */ + documentOutline; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepFileBreakdown'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'document_outline', kind: 'message', T: DocumentOutline }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepFileBreakdown().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepFileBreakdown().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepFileBreakdown().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepFileBreakdown, a, b); + } +}; +var CortexStepViewCodeItem = class _CortexStepViewCodeItem extends Message { + /** + * INPUTS + * + * @generated from field: string absolute_uri = 1; + */ + absoluteUri = ''; + /** + * @generated from field: repeated string node_paths = 4; + */ + nodePaths = []; + /** + * OUTPUTS + * + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem ccis = 5; + */ + ccis = []; + /** + * @generated from field: exa.cortex_pb.FilePermissionInteractionSpec file_permission_request = 6; + */ + filePermissionRequest; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepViewCodeItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'node_paths', kind: 'scalar', T: 9, repeated: true }, + { + no: 5, + name: 'ccis', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + { + no: 6, + name: 'file_permission_request', + kind: 'message', + T: FilePermissionInteractionSpec, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepViewCodeItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepViewCodeItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepViewCodeItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepViewCodeItem, a, b); + } +}; +var CortexStepWriteToFile = class _CortexStepWriteToFile extends Message { + /** + * Input + * + * @generated from field: string target_file_uri = 1; + */ + targetFileUri = ''; + /** + * code content is represented as an array of strings + * to avoid requiring the model to generate \n for line returns. + * GPT-4o sometimes generates double escapes (\\n), which + * causes syntax errors. + * + * @generated from field: repeated string code_content = 2; + */ + codeContent = []; + /** + * Output + * + * @generated from field: exa.diff_action_pb.DiffBlock diff = 3; + */ + diff; + /** + * @generated from field: bool file_created = 4; + */ + fileCreated = false; + /** + * The following is only used for Cascade, and indicates that the user has + * reviewed and either accepted or rejected the code changes. + * + * @generated from field: exa.cortex_pb.AcknowledgementType acknowledgement_type = 5; + */ + acknowledgementType = AcknowledgementType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepWriteToFile'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'target_file_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'code_content', kind: 'scalar', T: 9, repeated: true }, + { no: 3, name: 'diff', kind: 'message', T: DiffBlock }, + { + no: 4, + name: 'file_created', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'acknowledgement_type', + kind: 'enum', + T: proto3.getEnumType(AcknowledgementType), + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepWriteToFile().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepWriteToFile().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepWriteToFile().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepWriteToFile, a, b); + } +}; +var CortexStepSearchKnowledgeBase = class _CortexStepSearchKnowledgeBase extends Message { + /** + * Input + * + * @generated from field: repeated string queries = 1; + */ + queries = []; + /** + * @generated from field: exa.opensearch_clients_pb.TimeRange time_range = 3; + */ + timeRange; + /** + * @generated from field: repeated exa.opensearch_clients_pb.ConnectorType connector_types = 4; + */ + connectorTypes = []; + /** + * @generated from field: repeated string aggregate_ids = 7; + */ + aggregateIds = []; + /** + * Output + * + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseGroup knowledge_base_groups = 2; + */ + knowledgeBaseGroups = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepSearchKnowledgeBase'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'queries', kind: 'scalar', T: 9, repeated: true }, + { no: 3, name: 'time_range', kind: 'message', T: TimeRange }, + { + no: 4, + name: 'connector_types', + kind: 'enum', + T: proto3.getEnumType(ConnectorType), + repeated: true, + }, + { no: 7, name: 'aggregate_ids', kind: 'scalar', T: 9, repeated: true }, + { + no: 2, + name: 'knowledge_base_groups', + kind: 'message', + T: KnowledgeBaseGroup, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepSearchKnowledgeBase().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepSearchKnowledgeBase().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepSearchKnowledgeBase().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepSearchKnowledgeBase, a, b); + } +}; +var CortexStepLookupKnowledgeBase = class _CortexStepLookupKnowledgeBase extends Message { + /** + * Input + * + * @generated from field: repeated string urls = 1; + */ + urls = []; + /** + * @generated from field: repeated string document_ids = 2; + */ + documentIds = []; + /** + * Output + * + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseItemWithMetadata knowledge_base_items = 3; + */ + knowledgeBaseItems = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepLookupKnowledgeBase'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'urls', kind: 'scalar', T: 9, repeated: true }, + { no: 2, name: 'document_ids', kind: 'scalar', T: 9, repeated: true }, + { + no: 3, + name: 'knowledge_base_items', + kind: 'message', + T: KnowledgeBaseItemWithMetadata, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepLookupKnowledgeBase().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepLookupKnowledgeBase().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepLookupKnowledgeBase().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepLookupKnowledgeBase, a, b); + } +}; +var CortexStepSuggestedResponses = class _CortexStepSuggestedResponses extends Message { + /** + * Input + * + * @generated from field: repeated string suggestions = 1; + */ + suggestions = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepSuggestedResponses'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'suggestions', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepSuggestedResponses().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepSuggestedResponses().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepSuggestedResponses().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepSuggestedResponses, a, b); + } +}; +var CortexStepErrorMessage = class _CortexStepErrorMessage extends Message { + /** + * @generated from field: exa.cortex_pb.CortexErrorDetails error = 3; + */ + error; + /** + * @generated from field: bool should_show_user = 5; + */ + shouldShowUser = false; + /** + * @generated from field: bool should_show_model = 4; + */ + shouldShowModel = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepErrorMessage'; + static fields = proto3.util.newFieldList(() => [ + { no: 3, name: 'error', kind: 'message', T: CortexErrorDetails }, + { + no: 5, + name: 'should_show_user', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'should_show_model', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepErrorMessage().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepErrorMessage().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepErrorMessage().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepErrorMessage, a, b); + } +}; +var RunCommandOutput = class _RunCommandOutput extends Message { + /** + * Full output provided to Cascade. Note that for very large outputs, this may + * be truncated. + * + * @generated from field: string full = 1; + */ + full = ''; + /** + * Deprecated fields. + * + * @generated from field: string truncated = 2 [deprecated = true]; + * @deprecated + */ + truncated = ''; + /** + * @generated from field: uint32 num_lines_above = 3 [deprecated = true]; + * @deprecated + */ + numLinesAbove = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.RunCommandOutput'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'full', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'truncated', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'num_lines_above', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _RunCommandOutput().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RunCommandOutput().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RunCommandOutput().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RunCommandOutput, a, b); + } +}; +var CortexStepRunCommand = class _CortexStepRunCommand extends Message { + /** + * Command that is run if the user accepted. Same as proposed_command_line if + * not edited or if user rejected. + * + * @generated from field: string command_line = 23; + */ + commandLine = ''; + /** + * Command that was initially proposed by the model. + * + * @generated from field: string proposed_command_line = 25; + */ + proposedCommandLine = ''; + /** + * @generated from field: string cwd = 2; + */ + cwd = ''; + /** + * @generated from field: uint64 wait_ms_before_async = 12; + */ + waitMsBeforeAsync = protoInt64.zero; + /** + * Whether the command should be run without user approval, as decided by the + * model. Will not take effect unless the user has opted in to automated + * commands. + * + * @generated from field: bool should_auto_run = 15; + */ + shouldAutoRun = false; + /** + * Optional ID of the terminal to use for the command. If not specified or it + * doesn't exist, a new terminal will be created. + * + * @generated from field: string requested_terminal_id = 17; + */ + requestedTerminalId = ''; + /** + * Whether to run the command with sandbox override enabled. + * + * @generated from field: bool sandbox_override = 27; + */ + sandboxOverride = false; + /** + * OUTPUT + * blocking is set to true while the command is running synchronously, + * and then set to false when the command is backgrounded + * + * @generated from field: bool blocking = 11; + */ + blocking = false; + /** + * Only set if running in background. + * + * @generated from field: string command_id = 13; + */ + commandId = ''; + /** + * Will be unset if the exit code cannot be determined. + * + * @generated from field: optional int32 exit_code = 6; + */ + exitCode; + /** + * @generated from field: bool user_rejected = 14; + */ + userRejected = false; + /** + * @generated from field: exa.cortex_pb.AutoRunDecision auto_run_decision = 16; + */ + autoRunDecision = AutoRunDecision.UNSPECIFIED; + /** + * ID of the terminal used for the command. + * + * @generated from field: string terminal_id = 18; + */ + terminalId = ''; + /** + * @generated from field: exa.cortex_pb.RunCommandOutput combined_output = 21; + */ + combinedOutput; + /** + * Snapshot of the output at the time the command was backgrounded. + * + * @generated from field: exa.cortex_pb.RunCommandOutput combined_output_snapshot = 26; + */ + combinedOutputSnapshot; + /** + * True iff the IDE's terminal was used to execute the command. + * + * @generated from field: bool used_ide_terminal = 22; + */ + usedIdeTerminal = false; + /** + * Raw bytes from IDE execution used for debugging. + * + * @generated from field: string raw_debug_output = 24; + */ + rawDebugOutput = ''; + /** + * Deprecated fields. + * + * @generated from field: string command = 1 [deprecated = true]; + * @deprecated + */ + command = ''; + /** + * @generated from field: repeated string args = 3 [deprecated = true]; + * @deprecated + */ + args = []; + /** + * @generated from field: string stdout = 4 [deprecated = true]; + * @deprecated + */ + stdout = ''; + /** + * @generated from field: string stderr = 5 [deprecated = true]; + * @deprecated + */ + stderr = ''; + /** + * @generated from field: string stdout_buffer = 7 [deprecated = true]; + * @deprecated + */ + stdoutBuffer = ''; + /** + * @generated from field: string stderr_buffer = 8 [deprecated = true]; + * @deprecated + */ + stderrBuffer = ''; + /** + * @generated from field: uint32 stdout_lines_above = 9 [deprecated = true]; + * @deprecated + */ + stdoutLinesAbove = 0; + /** + * @generated from field: uint32 stderr_lines_above = 10 [deprecated = true]; + * @deprecated + */ + stderrLinesAbove = 0; + /** + * @generated from field: exa.cortex_pb.RunCommandOutput stdout_output = 19 [deprecated = true]; + * @deprecated + */ + stdoutOutput; + /** + * @generated from field: exa.cortex_pb.RunCommandOutput stderr_output = 20 [deprecated = true]; + * @deprecated + */ + stderrOutput; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepRunCommand'; + static fields = proto3.util.newFieldList(() => [ + { + no: 23, + name: 'command_line', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 25, + name: 'proposed_command_line', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'cwd', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'wait_ms_before_async', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 15, + name: 'should_auto_run', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 17, + name: 'requested_terminal_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 27, + name: 'sandbox_override', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 11, + name: 'blocking', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 13, + name: 'command_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 6, name: 'exit_code', kind: 'scalar', T: 5, opt: true }, + { + no: 14, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 16, + name: 'auto_run_decision', + kind: 'enum', + T: proto3.getEnumType(AutoRunDecision), + }, + { + no: 18, + name: 'terminal_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 21, name: 'combined_output', kind: 'message', T: RunCommandOutput }, + { + no: 26, + name: 'combined_output_snapshot', + kind: 'message', + T: RunCommandOutput, + }, + { + no: 22, + name: 'used_ide_terminal', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 24, + name: 'raw_debug_output', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 1, + name: 'command', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'args', kind: 'scalar', T: 9, repeated: true }, + { + no: 4, + name: 'stdout', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'stderr', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'stdout_buffer', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'stderr_buffer', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'stdout_lines_above', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 10, + name: 'stderr_lines_above', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 19, name: 'stdout_output', kind: 'message', T: RunCommandOutput }, + { no: 20, name: 'stderr_output', kind: 'message', T: RunCommandOutput }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepRunCommand().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepRunCommand().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepRunCommand().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepRunCommand, a, b); + } +}; +var CortexStepReadUrlContent = class _CortexStepReadUrlContent extends Message { + /** + * INPUTS + * + * @generated from field: string url = 1; + */ + url = ''; + /** + * OUTPUTS + * + * @generated from field: exa.codeium_common_pb.KnowledgeBaseItem web_document = 2; + */ + webDocument; + /** + * Sometimes the URL passed in may not be the same as the one actually used. + * For example, we will redirect Mintlify documentation sites to their + * LLM-friendly pages: + * https://docs.antigravity.com --> + * https://docs.antigravity.com/llms-full.txt + * + * @generated from field: string resolved_url = 3; + */ + resolvedUrl = ''; + /** + * Latency of the web document retrieval in milliseconds. + * + * @generated from field: uint32 latency_ms = 4; + */ + latencyMs = 0; + /** + * @generated from field: bool user_rejected = 5; + */ + userRejected = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepReadUrlContent'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'web_document', kind: 'message', T: KnowledgeBaseItem }, + { + no: 3, + name: 'resolved_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'latency_ms', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepReadUrlContent().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepReadUrlContent().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepReadUrlContent().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepReadUrlContent, a, b); + } +}; +var CortexStepReadKnowledgeBaseItem = class _CortexStepReadKnowledgeBaseItem extends Message { + /** + * INPUTS + * + * @generated from field: string identifier = 1; + */ + identifier = ''; + /** + * OUTPUTS + * + * @generated from field: exa.codeium_common_pb.KnowledgeBaseItem knowledge_base_item = 2; + */ + knowledgeBaseItem; + /** + * @generated from field: exa.opensearch_clients_pb.ConnectorType connector_type = 3; + */ + connectorType = ConnectorType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepReadKnowledgeBaseItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'identifier', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'knowledge_base_item', + kind: 'message', + T: KnowledgeBaseItem, + }, + { + no: 3, + name: 'connector_type', + kind: 'enum', + T: proto3.getEnumType(ConnectorType), + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepReadKnowledgeBaseItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepReadKnowledgeBaseItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepReadKnowledgeBaseItem().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepReadKnowledgeBaseItem, a, b); + } +}; +var CortexStepSendCommandInput = class _CortexStepSendCommandInput extends Message { + /** + * INPUTS + * The command ID to send input to (from run_command) + * + * @generated from field: string command_id = 1; + */ + commandId = ''; + /** + * The input to send + * + * @generated from field: string input = 2; + */ + input = ''; + /** + * Whether the command should be run without user approval, as decided by the + * model. Will not take effect unless the user has opted in to automated + * commands. + * + * @generated from field: bool should_auto_run = 3; + */ + shouldAutoRun = false; + /** + * Whether the command should terminate after being sent the input. + * + * @generated from field: bool terminate = 6; + */ + terminate = false; + /** + * Amount of time to wait for output after sending input. + * + * @generated from field: int64 wait_ms = 7; + */ + waitMs = protoInt64.zero; + /** + * OUTPUTS + * + * @generated from field: bool user_rejected = 4; + */ + userRejected = false; + /** + * @generated from field: exa.cortex_pb.AutoRunDecision auto_run_decision = 5; + */ + autoRunDecision = AutoRunDecision.UNSPECIFIED; + /** + * output captured after waiting for wait_ms. + * + * @generated from field: exa.cortex_pb.RunCommandOutput output = 8; + */ + output; + /** + * True if the command is still running after waiting for wait_ms. + * + * @generated from field: bool running = 9; + */ + running = false; + /** + * Exit code of the command if it terminated before wait_ms. + * + * @generated from field: optional int32 exit_code = 10; + */ + exitCode; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepSendCommandInput'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'command_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'input', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'should_auto_run', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'terminate', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'wait_ms', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 4, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'auto_run_decision', + kind: 'enum', + T: proto3.getEnumType(AutoRunDecision), + }, + { no: 8, name: 'output', kind: 'message', T: RunCommandOutput }, + { + no: 9, + name: 'running', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 10, name: 'exit_code', kind: 'scalar', T: 5, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepSendCommandInput().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepSendCommandInput().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepSendCommandInput().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepSendCommandInput, a, b); + } +}; +var CortexStepViewContentChunk = class _CortexStepViewContentChunk extends Message { + /** + * INPUTS + * The URL of the chunk to view. + * + * @generated from field: string document_id = 5; + */ + documentId = ''; + /** + * The position of the chunk. + * + * @generated from field: int32 position = 2; + */ + position = 0; + /** + * OUTPUTS + * The knowledge base item corresponding to the chunk with _only_ the chunk + * that is desired. Specifically, there will be one chunk in the chunks array. + * + * @generated from field: exa.codeium_common_pb.KnowledgeBaseItem cropped_item = 4; + */ + croppedItem; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepViewContentChunk'; + static fields = proto3.util.newFieldList(() => [ + { + no: 5, + name: 'document_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'position', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { no: 4, name: 'cropped_item', kind: 'message', T: KnowledgeBaseItem }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepViewContentChunk().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepViewContentChunk().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepViewContentChunk().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepViewContentChunk, a, b); + } +}; +var CortexStepSearchWeb = class _CortexStepSearchWeb extends Message { + /** + * INPUTS + * The query to search for. + * + * @generated from field: string query = 1; + */ + query = ''; + /** + * Optional domain for the search to prioritize. + * + * @generated from field: string domain = 3; + */ + domain = ''; + /** + * OUTPUTS + * A list of web documents that match the web search query. + * + * @generated from field: repeated exa.codeium_common_pb.KnowledgeBaseItem web_documents = 2; + */ + webDocuments = []; + /** + * The URL to view the full search results in a browser. + * + * @generated from field: string web_search_url = 4; + */ + webSearchUrl = ''; + /** + * This variable is only for an experimental feature where we use a third + * party API to perform web search. + * + * @generated from field: string summary = 5; + */ + summary = ''; + /** + * @generated from field: exa.codeium_common_pb.ThirdPartyWebSearchConfig third_party_config = 6; + */ + thirdPartyConfig; + /** + * The type of search performed. Default is SEARCH_WEB_TYPE_WEB. + * + * @generated from field: exa.cortex_pb.SearchWebType search_type = 7; + */ + searchType = SearchWebType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepSearchWeb'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'domain', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'web_documents', + kind: 'message', + T: KnowledgeBaseItem, + repeated: true, + }, + { + no: 4, + name: 'web_search_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'third_party_config', + kind: 'message', + T: ThirdPartyWebSearchConfig, + }, + { + no: 7, + name: 'search_type', + kind: 'enum', + T: proto3.getEnumType(SearchWebType), + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepSearchWeb().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepSearchWeb().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepSearchWeb().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepSearchWeb, a, b); + } +}; +var CortexStepReadDeploymentConfig = class _CortexStepReadDeploymentConfig extends Message { + /** + * INPUTS + * The absolute path to the web app's project directory. + * + * @generated from field: string project_path = 1; + */ + projectPath = ''; + /** + * OUTPUTS + * The deployment configuration file. + * + * @generated from field: string deployment_config_uri = 2; + */ + deploymentConfigUri = ''; + /** + * The config that was read from the existing deployment config file. If no + * config file existed, this will be empty. + * + * @generated from field: exa.codeium_common_pb.WebAppDeploymentConfig deployment_config = 3; + */ + deploymentConfig; + /** + * Whether there are any missing files that need to be created before + * deployment. For example, Netlify sites requires a `netlify.toml` file. + * + * @generated from field: repeated string missing_file_uris = 4; + */ + missingFileUris = []; + /** + * Whether we are planning on uploading any node_modules files based on the + * ignore files. We automatically add node_modules to the ignore files so this + * should rarely be true. + * + * @generated from field: bool will_upload_node_modules = 5; + */ + willUploadNodeModules = false; + /** + * Whether we are planning on uploading any dist files based on the ignore + * files. + * + * @generated from field: bool will_upload_dist = 6; + */ + willUploadDist = false; + /** + * The ignore files that the user has in this project. + * + * @generated from field: repeated string ignore_file_uris = 7; + */ + ignoreFileUris = []; + /** + * The number of files that will be uploaded. + * + * @generated from field: uint32 num_files_to_upload = 8; + */ + numFilesToUpload = 0; + /** + * Any .env files that the user has in this project that will be uploaded. + * + * @generated from field: repeated string env_file_uris = 9; + */ + envFileUris = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepReadDeploymentConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'project_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'deployment_config_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'deployment_config', + kind: 'message', + T: WebAppDeploymentConfig, + }, + { no: 4, name: 'missing_file_uris', kind: 'scalar', T: 9, repeated: true }, + { + no: 5, + name: 'will_upload_node_modules', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'will_upload_dist', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 7, name: 'ignore_file_uris', kind: 'scalar', T: 9, repeated: true }, + { + no: 8, + name: 'num_files_to_upload', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 9, name: 'env_file_uris', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepReadDeploymentConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepReadDeploymentConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepReadDeploymentConfig().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepReadDeploymentConfig, a, b); + } +}; +var CortexStepDeployWebApp = class _CortexStepDeployWebApp extends Message { + /** + * INPUTS + * The absolute path to the web app's project directory. + * + * @generated from field: string project_path = 1; + */ + projectPath = ''; + /** + * The subdomain of the app as determined by Cascade. This will only be used + * for new deployments and will be the value used in the URL (ie. + * .antigravity.app). + * + * @generated from field: string subdomain = 2; + */ + subdomain = ''; + /** + * The project ID used for deploying to an existing project. If this value is + * populated, we will consider this to be a deploy to an existing project. + * + * @generated from field: string project_id = 11; + */ + projectId = ''; + /** + * JS framework used for the app (ie. nextjs, sveltekit, etc.). This varies + * based on the provider. + * + * @generated from field: string framework = 3; + */ + framework = ''; + /** + * Whether the user confirmed to run the deployment. + * + * @generated from field: bool user_confirmed = 4; + */ + userConfirmed = false; + /** + * Map from absolute file path to the status of the file's upload to the app. + * + * @generated from field: map file_upload_status = 5; + */ + fileUploadStatus = {}; + /** + * If successful, the Antigravity deployment record. + * + * @generated from field: exa.codeium_common_pb.AntigravityDeployment deployment = 6; + */ + deployment; + /** + * The URI for the deployment config file. Does not mean it was written to. + * This is the target path that the deployment config will be written to. + * + * @generated from field: string deployment_config_uri = 7; + */ + deploymentConfigUri = ''; + /** + * The config that was written to the deployment config file. If the config + * was not written for some reason, this will be empty. + * + * @generated from field: exa.codeium_common_pb.WebAppDeploymentConfig deployment_config_output = 8; + */ + deploymentConfigOutput; + /** + * The subdomain that was retrieved from the provider if the input specified a + * project ID. + * + * @generated from field: string subdomain_for_project_id = 12; + */ + subdomainForProjectId = ''; + /** + * The subdomain that the user specified in the step input. + * + * @generated from field: string subdomain_user_specified = 13; + */ + subdomainUserSpecified = ''; + /** + * The subdomain that was ultimately used for the deployment. For updating an + * existing deployment, this will be the subdomain used by the existing + * deployment. + * + * @generated from field: string subdomain_used = 9; + */ + subdomainUsed = ''; + /** + * The deploy target that was retrieved from the provider if the input + * specified a project ID. + * + * @generated from field: exa.codeium_common_pb.DeployTarget deploy_target_for_project_id = 15; + */ + deployTargetForProjectId; + /** + * The deploy target that the user specified in the step input. + * + * @generated from field: exa.codeium_common_pb.DeployTarget deploy_target_user_specified = 16; + */ + deployTargetUserSpecified; + /** + * The deploy target that was ultimately used for the deployment. For updating + * an existing deployment, this will be the deploy target used by the existing + * deployment. + * + * @generated from field: exa.codeium_common_pb.DeployTarget deploy_target_used = 17; + */ + deployTargetUsed; + /** + * The project ID that was ultimately used for the deployment. For updating an + * existing deployment, this will be the project ID used by the existing + * deployment. For new deployments, this will be empty. + * + * @generated from field: string project_id_used = 14; + */ + projectIdUsed = ''; + /** + * Claim URL for the deployment (if unclaimed). + * + * @generated from field: string claim_url = 10; + */ + claimUrl = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepDeployWebApp'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'project_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'subdomain', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 11, + name: 'project_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'framework', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'user_confirmed', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'file_upload_status', + kind: 'map', + K: 9, + V: { kind: 'enum', T: proto3.getEnumType(DeployWebAppFileUploadStatus) }, + }, + { no: 6, name: 'deployment', kind: 'message', T: AntigravityDeployment }, + { + no: 7, + name: 'deployment_config_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'deployment_config_output', + kind: 'message', + T: WebAppDeploymentConfig, + }, + { + no: 12, + name: 'subdomain_for_project_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 13, + name: 'subdomain_user_specified', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'subdomain_used', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 15, + name: 'deploy_target_for_project_id', + kind: 'message', + T: DeployTarget, + }, + { + no: 16, + name: 'deploy_target_user_specified', + kind: 'message', + T: DeployTarget, + }, + { no: 17, name: 'deploy_target_used', kind: 'message', T: DeployTarget }, + { + no: 14, + name: 'project_id_used', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'claim_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepDeployWebApp().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepDeployWebApp().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepDeployWebApp().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepDeployWebApp, a, b); + } +}; +var CortexStepCheckDeployStatus = class _CortexStepCheckDeployStatus extends Message { + /** + * INPUTS + * The Antigravity deployment ID (primary key of the `antigravity_deployments` + * table) to check. + * + * @generated from field: string antigravity_deployment_id = 1; + */ + antigravityDeploymentId = ''; + /** + * The Antigravity deployment record. + * + * @generated from field: exa.codeium_common_pb.AntigravityDeployment deployment = 2; + */ + deployment; + /** + * Build status. + * + * @generated from field: exa.codeium_common_pb.DeploymentBuildStatus build_status = 3; + */ + buildStatus = DeploymentBuildStatus.UNSPECIFIED; + /** + * The one line error message, if the build errored. + * + * @generated from field: string build_error = 4; + */ + buildError = ''; + /** + * The logs for the build. Depending on the provider, this may not be + * populated. + * + * @generated from field: string build_logs = 5; + */ + buildLogs = ''; + /** + * Whether the app has been claimed. + * + * @generated from field: bool is_claimed = 6; + */ + isClaimed = false; + /** + * The URL to claim the app if it has not yet been claimed. + * + * @generated from field: string claim_url = 7; + */ + claimUrl = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCheckDeployStatus'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'antigravity_deployment_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'deployment', kind: 'message', T: AntigravityDeployment }, + { + no: 3, + name: 'build_status', + kind: 'enum', + T: proto3.getEnumType(DeploymentBuildStatus), + }, + { + no: 4, + name: 'build_error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'build_logs', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'is_claimed', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'claim_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCheckDeployStatus().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepCheckDeployStatus().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCheckDeployStatus().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCheckDeployStatus, a, b); + } +}; +var CortexStepClipboard = class _CortexStepClipboard extends Message { + /** + * @generated from field: string content = 1; + */ + content = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepClipboard'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepClipboard().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepClipboard().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepClipboard().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepClipboard, a, b); + } +}; +var ExecutorMetadata = class _ExecutorMetadata extends Message { + /** + * @generated from field: exa.cortex_pb.ExecutorTerminationReason termination_reason = 1; + */ + terminationReason = ExecutorTerminationReason.UNSPECIFIED; + /** + * @generated from field: int32 num_generator_invocations = 2; + */ + numGeneratorInvocations = 0; + /** + * The inclusive index of the last step that was executed in this execution + * loop. + * + * @generated from field: int32 last_step_idx = 3; + */ + lastStepIdx = 0; + /** + * Whether the executor proceeded with auto-continue, per the user settings. + * This is only relevant if termination_reason is MAX_INVOCATIONS. + * + * @generated from field: bool proceeded_with_auto_continue = 4; + */ + proceededWithAutoContinue = false; + /** + * @generated from field: int32 num_forced_invocations = 5 [deprecated = true]; + * @deprecated + */ + numForcedInvocations = 0; + /** + * Metrics records for the trajectory segment, only populated for dev mode. + * + * @generated from field: repeated exa.codeium_common_pb.MetricsRecord segment_records = 6; + */ + segmentRecords = []; + /** + * @generated from field: repeated exa.codeium_common_pb.MetricsRecord trajectory_records = 7; + */ + trajectoryRecords = []; + /** + * Trajectory state at the end of execution as GenerateContentRequest. + * Relevant for training data extraction. + * Type: google.ai.generativelanguage.v1main.GenerateContentRequest + * Uses Any to avoid a direct proto import dependency on generative_service + * + * @generated from field: string execution_id = 9; + */ + executionId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ExecutorMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'termination_reason', + kind: 'enum', + T: proto3.getEnumType(ExecutorTerminationReason), + }, + { + no: 2, + name: 'num_generator_invocations', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'last_step_idx', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'proceeded_with_auto_continue', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'num_forced_invocations', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'segment_records', + kind: 'message', + T: MetricsRecord, + repeated: true, + }, + { + no: 7, + name: 'trajectory_records', + kind: 'message', + T: MetricsRecord, + repeated: true, + }, + { + no: 9, + name: 'execution_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ExecutorMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ExecutorMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ExecutorMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ExecutorMetadata, a, b); + } +}; +var CortexStepLintDiff = class _CortexStepLintDiff extends Message { + /** + * @generated from field: exa.cortex_pb.LintDiffType type = 1; + */ + type = LintDiffType.UNSPECIFIED; + /** + * @generated from field: exa.codeium_common_pb.CodeDiagnostic lint = 2; + */ + lint; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepLintDiff'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'type', kind: 'enum', T: proto3.getEnumType(LintDiffType) }, + { no: 2, name: 'lint', kind: 'message', T: CodeDiagnostic }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepLintDiff().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepLintDiff().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepLintDiff().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepLintDiff, a, b); + } +}; +var BrainEntry = class _BrainEntry extends Message { + /** + * @generated from field: string id = 1; + */ + id = ''; + /** + * @generated from field: exa.cortex_pb.BrainEntryType type = 2; + */ + type = BrainEntryType.UNSPECIFIED; + /** + * TODO(matt): Consider adding more structure to the content. + * + * @generated from field: string content = 3; + */ + content = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrainEntry'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(BrainEntryType), + }, + { + no: 3, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _BrainEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrainEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrainEntry().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrainEntry, a, b); + } +}; +var PlanEntryDeltaSummary = class _PlanEntryDeltaSummary extends Message { + /** + * @generated from field: repeated string items_added = 1; + */ + itemsAdded = []; + /** + * @generated from field: repeated string items_completed = 2; + */ + itemsCompleted = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.PlanEntryDeltaSummary'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'items_added', kind: 'scalar', T: 9, repeated: true }, + { no: 2, name: 'items_completed', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _PlanEntryDeltaSummary().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _PlanEntryDeltaSummary().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _PlanEntryDeltaSummary().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_PlanEntryDeltaSummary, a, b); + } +}; +var BrainEntryDeltaSummary = class _BrainEntryDeltaSummary extends Message { + /** + * @generated from oneof exa.cortex_pb.BrainEntryDeltaSummary.summary + */ + summary = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrainEntryDeltaSummary'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'plan', + kind: 'message', + T: PlanEntryDeltaSummary, + oneof: 'summary', + }, + { + no: 2, + name: 'task', + kind: 'message', + T: TaskEntryDeltaSummary, + oneof: 'summary', + }, + ]); + static fromBinary(bytes, options) { + return new _BrainEntryDeltaSummary().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrainEntryDeltaSummary().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrainEntryDeltaSummary().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrainEntryDeltaSummary, a, b); + } +}; +var BrainEntryDelta = class _BrainEntryDelta extends Message { + /** + * @generated from field: exa.cortex_pb.BrainEntry before = 1; + */ + before; + /** + * @generated from field: exa.cortex_pb.BrainEntry after = 2; + */ + after; + /** + * @generated from field: string absolute_path_uri = 3; + */ + absolutePathUri = ''; + /** + * Optional summary of the delta, specific to the type of entry. + * + * @generated from field: exa.cortex_pb.BrainEntryDeltaSummary summary = 4; + */ + summary; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrainEntryDelta'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'before', kind: 'message', T: BrainEntry }, + { no: 2, name: 'after', kind: 'message', T: BrainEntry }, + { + no: 3, + name: 'absolute_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'summary', kind: 'message', T: BrainEntryDeltaSummary }, + ]); + static fromBinary(bytes, options) { + return new _BrainEntryDelta().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrainEntryDelta().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrainEntryDelta().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_BrainEntryDelta, a, b); + } +}; +var TaskItem = class _TaskItem extends Message { + /** + * @generated from field: string id = 1; + */ + id = ''; + /** + * @generated from field: string content = 2; + */ + content = ''; + /** + * @generated from field: exa.cortex_pb.TaskStatus status = 3; + */ + status = TaskStatus.UNSPECIFIED; + /** + * Empty for root-level tasks + * + * @generated from field: string parent_id = 4; + */ + parentId = ''; + /** + * ID of previous sibling (empty for first child) + * + * @generated from field: string prev_sibling_id = 5; + */ + prevSiblingId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TaskItem'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'status', kind: 'enum', T: proto3.getEnumType(TaskStatus) }, + { + no: 4, + name: 'parent_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'prev_sibling_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _TaskItem().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TaskItem().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TaskItem().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TaskItem, a, b); + } +}; +var TaskDelta = class _TaskDelta extends Message { + /** + * @generated from field: exa.cortex_pb.TaskDeltaType type = 1; + */ + type = TaskDeltaType.UNSPECIFIED; + /** + * @generated from field: string id = 2; + */ + id = ''; + /** + * Task data - always populated for relevant operations + * + * Current/new content + * + * @generated from field: string content = 3; + */ + content = ''; + /** + * Current/new status + * + * @generated from field: exa.cortex_pb.TaskStatus status = 4; + */ + status = TaskStatus.UNSPECIFIED; + /** + * For add/move operations - positioning info + * + * Target parent (empty for root level) + * + * @generated from field: string parent_id = 5; + */ + parentId = ''; + /** + * Insert after this sibling (empty for first position) + * + * @generated from field: string prev_sibling_id = 6; + */ + prevSiblingId = ''; + /** + * For move operations - original position (optional, for context) + * + * Original parent id (empty for root level) + * + * @generated from field: string from_parent = 7; + */ + fromParent = ''; + /** + * Original previous sibling id (empty for first position) + * + * @generated from field: string from_prev_sibling = 8; + */ + fromPrevSibling = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TaskDelta'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'type', kind: 'enum', T: proto3.getEnumType(TaskDeltaType) }, + { + no: 2, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'status', kind: 'enum', T: proto3.getEnumType(TaskStatus) }, + { + no: 5, + name: 'parent_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'prev_sibling_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'from_parent', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'from_prev_sibling', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _TaskDelta().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TaskDelta().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TaskDelta().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TaskDelta, a, b); + } +}; +var TaskEntryDeltaSummary = class _TaskEntryDeltaSummary extends Message { + /** + * @generated from field: repeated exa.cortex_pb.TaskDelta deltas = 1; + */ + deltas = []; + /** + * High-level summary counts for quick overview + * + * @generated from field: int32 items_added = 2; + */ + itemsAdded = 0; + /** + * Tasks completed & deleted + * + * @generated from field: int32 items_pruned = 3; + */ + itemsPruned = 0; + /** + * Tasks never completed & deleted + * + * @generated from field: int32 items_deleted = 4; + */ + itemsDeleted = 0; + /** + * Status or content changes + * + * @generated from field: int32 items_updated = 5; + */ + itemsUpdated = 0; + /** + * Parent or order changes + * + * @generated from field: int32 items_moved = 6; + */ + itemsMoved = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TaskEntryDeltaSummary'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'deltas', kind: 'message', T: TaskDelta, repeated: true }, + { + no: 2, + name: 'items_added', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'items_pruned', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'items_deleted', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'items_updated', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'items_moved', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _TaskEntryDeltaSummary().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TaskEntryDeltaSummary().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TaskEntryDeltaSummary().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TaskEntryDeltaSummary, a, b); + } +}; +var CortexStepBrainUpdate = class _CortexStepBrainUpdate extends Message { + /** + * Inputs + * + * @generated from oneof exa.cortex_pb.CortexStepBrainUpdate.target + */ + target = { case: void 0 }; + /** + * The trigger for the update. + * + * @generated from field: exa.cortex_pb.BrainUpdateTrigger trigger = 3; + */ + trigger = BrainUpdateTrigger.UNSPECIFIED; + /** + * Outputs + * + * @generated from field: repeated exa.cortex_pb.BrainEntryDelta deltas = 2; + */ + deltas = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrainUpdate'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'entry_type', + kind: 'enum', + T: proto3.getEnumType(BrainEntryType), + oneof: 'target', + }, + { + no: 3, + name: 'trigger', + kind: 'enum', + T: proto3.getEnumType(BrainUpdateTrigger), + }, + { + no: 2, + name: 'deltas', + kind: 'message', + T: BrainEntryDelta, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrainUpdate().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrainUpdate().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrainUpdate().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrainUpdate, a, b); + } +}; +var CortexStepBrowserSubagent = class _CortexStepBrowserSubagent extends Message { + /** + * Inputs + * + * @generated from field: string task = 1; + */ + task = ''; + /** + * ID of the subagent to use. If empty, a new subagent will be created. + * + * @generated from field: string reused_subagent_id = 9; + */ + reusedSubagentId = ''; + /** + * Name of the recording file (without extension) when saving as artifact. + * + * @generated from field: string recording_name = 7; + */ + recordingName = ''; + /** + * Outputs + * + * @generated from field: string result = 2; + */ + result = ''; + /** + * Title of the task + * + * @generated from field: string task_name = 3; + */ + taskName = ''; + /** + * Path to the recording of the subagent's work + * + * @generated from field: string recording_path = 4; + */ + recordingPath = ''; + /** + * Status of the recording video generation + * + * @generated from field: exa.cortex_pb.RecordingGenerationStatus recording_generation_status = 6; + */ + recordingGenerationStatus = RecordingGenerationStatus.UNSPECIFIED; + /** + * ID of the subagent (same as subagent_id if a subagent was not newly created + * by this invocation) + * + * @generated from field: string subagent_id = 8; + */ + subagentId = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserSubagent'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'task', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 9, + name: 'reused_subagent_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'recording_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'result', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'task_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'recording_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'recording_generation_status', + kind: 'enum', + T: proto3.getEnumType(RecordingGenerationStatus), + }, + { + no: 8, + name: 'subagent_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserSubagent().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserSubagent().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserSubagent().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserSubagent, a, b); + } +}; +var KnowledgeConfig = class _KnowledgeConfig extends Message { + /** + * @generated from field: optional bool enabled = 1; + */ + enabled; + /** + * @generated from field: exa.codeium_common_pb.Model model = 2; + */ + model = Model.UNSPECIFIED; + /** + * @generated from field: uint32 max_context_tokens = 3; + */ + maxContextTokens = 0; + /** + * @generated from field: uint32 max_invocations = 4; + */ + maxInvocations = 0; + /** + * @generated from field: uint32 min_turns_between_knowledge_generation = 5; + */ + minTurnsBetweenKnowledgeGeneration = 0; + /** + * @generated from field: uint32 max_knowledge_items = 6; + */ + maxKnowledgeItems = 0; + /** + * @generated from field: uint32 max_artifacts_per_ki = 7; + */ + maxArtifactsPerKi = 0; + /** + * @generated from field: uint32 max_title_length = 8; + */ + maxTitleLength = 0; + /** + * @generated from field: uint32 max_summary_length = 9; + */ + maxSummaryLength = 0; + /** + * @generated from field: optional bool enable_ki_insertion = 10; + */ + enableKiInsertion; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.KnowledgeConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { no: 2, name: 'model', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 3, + name: 'max_context_tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'max_invocations', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'min_turns_between_knowledge_generation', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 6, + name: 'max_knowledge_items', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 7, + name: 'max_artifacts_per_ki', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 8, + name: 'max_title_length', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 9, + name: 'max_summary_length', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 10, name: 'enable_ki_insertion', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _KnowledgeConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _KnowledgeConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _KnowledgeConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_KnowledgeConfig, a, b); + } +}; +var CortexStepKnowledgeGeneration = class _CortexStepKnowledgeGeneration extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepKnowledgeGeneration'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CortexStepKnowledgeGeneration().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepKnowledgeGeneration().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepKnowledgeGeneration().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepKnowledgeGeneration, a, b); + } +}; +var CortexStepOpenBrowserUrl = class _CortexStepOpenBrowserUrl extends Message { + /** + * Inputs + * + * @generated from field: string url = 1; + */ + url = ''; + /** + * Page ID (optional) to replace with the new URL. + * + * @generated from field: string page_id_to_replace = 8; + */ + pageIdToReplace = ''; + /** + * The decision for whether to auto open the URL in the Browser. + * + * @generated from field: exa.cortex_pb.AutoRunDecision auto_run_decision = 2; + */ + autoRunDecision = AutoRunDecision.UNSPECIFIED; + /** + * Whether the user rejected to open the URL (if the auto run decision was not + * to auto run). + * + * @generated from field: bool user_rejected = 3; + */ + userRejected = false; + /** + * The page ID of the opened page (from the Antigravity Browser service). + * + * @generated from field: string page_id = 4; + */ + pageId = ''; + /** + * The web document captured from the opened page. + * + * @generated from field: exa.codeium_common_pb.KnowledgeBaseItem web_document = 5; + */ + webDocument; + /** + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 6; + */ + pageMetadata; + /** + * Deprecated use media_screenshot + * + * @generated from field: exa.codeium_common_pb.ImageData screenshot = 7 [deprecated = true]; + * @deprecated + */ + screenshot; + /** + * The screenshot of the opened page (can be either full page or viewport). + * + * @generated from field: exa.codeium_common_pb.Media media_screenshot = 10; + */ + mediaScreenshot; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 9; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepOpenBrowserUrl'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'page_id_to_replace', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'auto_run_decision', + kind: 'enum', + T: proto3.getEnumType(AutoRunDecision), + }, + { + no: 3, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'web_document', kind: 'message', T: KnowledgeBaseItem }, + { no: 6, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { no: 7, name: 'screenshot', kind: 'message', T: ImageData }, + { no: 10, name: 'media_screenshot', kind: 'message', T: Media }, + { + no: 9, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepOpenBrowserUrl().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepOpenBrowserUrl().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepOpenBrowserUrl().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepOpenBrowserUrl, a, b); + } +}; +var CortexStepExecuteBrowserJavaScript = class _CortexStepExecuteBrowserJavaScript extends Message { + /** + * An at most 20 character title describing the task in the imperative form. + * Will be displayed in the step UI as the title of the tool. + * + * @generated from field: string title = 9; + */ + title = ''; + /** + * page_id of the Browser page to execute the JavaScript on. + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * JavaScript to execute on the page. + * + * @generated from field: string javascript_source = 2; + */ + javascriptSource = ''; + /** + * Human-readable description of the JavaScript to execute. + * + * @generated from field: string javascript_description = 3; + */ + javascriptDescription = ''; + /** + * Whether the command should be run without user approval, as decided by the + * model. Will not take effect unless the user has opted in to automated + * commands. + * + * @generated from field: bool should_auto_run = 10; + */ + shouldAutoRun = false; + /** + * The reason why the step is waiting for user input. Only relevant when + * the step status is WAITING. + * + * @generated from field: exa.cortex_pb.BrowserActionWaitingReason waiting_reason = 13; + */ + waitingReason = BrowserActionWaitingReason.UNSPECIFIED; + /** + * Whether the user rejected to execute the JavaScript (if the auto run + * decision was not to auto run). + * + * @generated from field: bool user_rejected = 4; + */ + userRejected = false; + /** + * @generated from field: exa.codeium_common_pb.ImageData screenshot_end = 5 [deprecated = true]; + * @deprecated + */ + screenshotEnd; + /** + * Screenshot of the page after executing the JavaScript. + * + * @generated from field: exa.codeium_common_pb.Media media_screenshot_end = 12; + */ + mediaScreenshotEnd; + /** + * Metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 6; + */ + pageMetadata; + /** + * How long it took to execute the JavaScript. + * + * @generated from field: uint64 execution_duration_ms = 7; + */ + executionDurationMs = protoInt64.zero; + /** + * Result of the JavaScript execution. + * + * @generated from field: string javascript_result = 8; + */ + javascriptResult = ''; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 11; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepExecuteBrowserJavaScript'; + static fields = proto3.util.newFieldList(() => [ + { + no: 9, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'javascript_source', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'javascript_description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 10, + name: 'should_auto_run', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 13, + name: 'waiting_reason', + kind: 'enum', + T: proto3.getEnumType(BrowserActionWaitingReason), + }, + { + no: 4, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 5, name: 'screenshot_end', kind: 'message', T: ImageData }, + { no: 12, name: 'media_screenshot_end', kind: 'message', T: Media }, + { no: 6, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 7, + name: 'execution_duration_ms', + kind: 'scalar', + T: 4, + /* ScalarType.UINT64 */ + }, + { + no: 8, + name: 'javascript_result', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 11, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepExecuteBrowserJavaScript().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepExecuteBrowserJavaScript().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CortexStepExecuteBrowserJavaScript().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepExecuteBrowserJavaScript, a, b); + } +}; +var CortexStepReadBrowserPage = class _CortexStepReadBrowserPage extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * The web document captured from the opened page. + * + * @generated from field: exa.codeium_common_pb.KnowledgeBaseItem web_document = 2; + */ + webDocument; + /** + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 3; + */ + pageMetadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepReadBrowserPage'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'web_document', kind: 'message', T: KnowledgeBaseItem }, + { no: 3, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepReadBrowserPage().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepReadBrowserPage().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepReadBrowserPage().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepReadBrowserPage, a, b); + } +}; +var CortexStepBrowserGetDom = class _CortexStepBrowserGetDom extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * The DOM tree of the page. + * + * @generated from field: exa.codeium_common_pb.DOMTree dom_tree = 2 [deprecated = true]; + * @deprecated + */ + domTree; + /** + * The serialized DOM tree of the page. + * + * @generated from field: string serialized_dom_tree = 3 [deprecated = true]; + * @deprecated + */ + serializedDomTree = ''; + /** + * The URI of a txt file storing the serialized DOM tree of the page. + * + * @generated from field: string serialized_dom_tree_uri = 5; + */ + serializedDomTreeUri = ''; + /** + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 4; + */ + pageMetadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserGetDom'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'dom_tree', kind: 'message', T: DOMTree }, + { + no: 3, + name: 'serialized_dom_tree', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'serialized_dom_tree_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 4, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserGetDom().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserGetDom().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserGetDom().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserGetDom, a, b); + } +}; +var CortexStepListBrowserPages = class _CortexStepListBrowserPages extends Message { + /** + * Outputs + * + * @generated from field: repeated exa.codeium_common_pb.BrowserPageMetadata pages = 1; + */ + pages = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepListBrowserPages'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'pages', + kind: 'message', + T: BrowserPageMetadata, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepListBrowserPages().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepListBrowserPages().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepListBrowserPages().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepListBrowserPages, a, b); + } +}; +var CortexStepCaptureBrowserScreenshot = class _CortexStepCaptureBrowserScreenshot extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * Whether to save the screenshot as an artifact. + * + * @generated from field: bool save_screenshot = 7; + */ + saveScreenshot = false; + /** + * Name of the screenshot file (without extension) when saving as artifact. + * + * @generated from field: string screenshot_name = 10; + */ + screenshotName = ''; + /** + * Whether to capture a screenshot of a specific element by index. + * + * @generated from field: bool capture_by_element_index = 8; + */ + captureByElementIndex = false; + /** + * The index of the element to capture (required if capture_by_element_index + * is true). + * + * @generated from field: int32 element_index = 9; + */ + elementIndex = 0; + /** + * Whether to capture more of the screen beyond the viewport (max height is + * 4000 pixels). + * + * @generated from field: bool capture_beyond_viewport = 12; + */ + captureBeyondViewport = false; + /** + * Whether the user rejected to take the screenshot (if the auto run decision + * was not to auto run). + * + * @generated from field: bool user_rejected = 2; + */ + userRejected = false; + /** + * Deprecated use media_screenshot + * + * @generated from field: exa.codeium_common_pb.ImageData screenshot = 3 [deprecated = true]; + * @deprecated + */ + screenshot; + /** + * The screenshot of the viewport. + * + * @generated from field: exa.codeium_common_pb.Media media_screenshot = 11; + */ + mediaScreenshot; + /** + * The captured screenshot viewport. + * + * @generated from field: exa.codeium_common_pb.Viewport screenshot_viewport = 13; + */ + screenshotViewport; + /** + * Metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 4; + */ + pageMetadata; + /** + * The decision for whether to auto capture the screenshot in the Browser. + * + * @generated from field: exa.cortex_pb.AutoRunDecision auto_run_decision = 5; + */ + autoRunDecision = AutoRunDecision.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCaptureBrowserScreenshot'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'save_screenshot', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 10, + name: 'screenshot_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'capture_by_element_index', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 9, + name: 'element_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 12, + name: 'capture_beyond_viewport', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 3, name: 'screenshot', kind: 'message', T: ImageData }, + { no: 11, name: 'media_screenshot', kind: 'message', T: Media }, + { no: 13, name: 'screenshot_viewport', kind: 'message', T: Viewport }, + { no: 4, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 5, + name: 'auto_run_decision', + kind: 'enum', + T: proto3.getEnumType(AutoRunDecision), + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCaptureBrowserScreenshot().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepCaptureBrowserScreenshot().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCaptureBrowserScreenshot().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCaptureBrowserScreenshot, a, b); + } +}; +var CortexStepClickBrowserPixel = class _CortexStepClickBrowserPixel extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * Coordinates within the viewport. + * + * X coordinate of the pixel to click + * + * @generated from field: int32 x = 2; + */ + x = 0; + /** + * Y coordinate of the pixel to click + * + * @generated from field: int32 y = 3; + */ + y = 0; + /** + * Optional click type (ex. left, right, double). Defaults to left click if + * not specified. + * + * @generated from field: exa.browser_pb.ClickType click_type = 7; + */ + clickType = ClickType.UNSPECIFIED; + /** + * Whether the user rejected to click (if the auto run decision was not to + * auto run). + * + * @generated from field: bool user_rejected = 4; + */ + userRejected = false; + /** + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 5; + */ + pageMetadata; + /** + * Screenshot of the page after clicking the pixel. Might not be populated, + * depends on CascadeConfig + * + * @generated from field: optional exa.codeium_common_pb.Media screenshot_with_click_feedback = 6; + */ + screenshotWithClickFeedback; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 8; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepClickBrowserPixel'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'x', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'y', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 7, + name: 'click_type', + kind: 'enum', + T: proto3.getEnumType(ClickType), + }, + { + no: 4, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 5, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 6, + name: 'screenshot_with_click_feedback', + kind: 'message', + T: Media, + opt: true, + }, + { + no: 8, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepClickBrowserPixel().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepClickBrowserPixel().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepClickBrowserPixel().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepClickBrowserPixel, a, b); + } +}; +var CortexStepAddAnnotation = class _CortexStepAddAnnotation extends Message { + /** + * Inputs + * + * @generated from field: exa.codeium_common_pb.CodeAnnotation annotation = 1; + */ + annotation; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepAddAnnotation'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'annotation', kind: 'message', T: CodeAnnotation }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepAddAnnotation().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepAddAnnotation().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepAddAnnotation().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepAddAnnotation, a, b); + } +}; +var CortexStepCaptureBrowserConsoleLogs = class _CortexStepCaptureBrowserConsoleLogs extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * Metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 2; + */ + pageMetadata; + /** + * The console logs. + * + * @generated from field: exa.codeium_common_pb.ConsoleLogScopeItem console_logs = 3; + */ + consoleLogs; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCaptureBrowserConsoleLogs'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { no: 3, name: 'console_logs', kind: 'message', T: ConsoleLogScopeItem }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCaptureBrowserConsoleLogs().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CortexStepCaptureBrowserConsoleLogs().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCaptureBrowserConsoleLogs().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCaptureBrowserConsoleLogs, a, b); + } +}; +var CascadePanelState = class _CascadePanelState extends Message { + /** + * @generated from field: exa.codeium_common_pb.PlanStatus plan_status = 1; + */ + planStatus; + /** + * @generated from field: exa.codeium_common_pb.UserSettings user_settings = 2; + */ + userSettings; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CascadePanelState'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'plan_status', kind: 'message', T: PlanStatus }, + { no: 2, name: 'user_settings', kind: 'message', T: UserSettings }, + ]); + static fromBinary(bytes, options) { + return new _CascadePanelState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CascadePanelState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CascadePanelState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CascadePanelState, a, b); + } +}; +var CortexStepCommandStatus = class _CortexStepCommandStatus extends Message { + /** + * Input + * + * @generated from field: string command_id = 1; + */ + commandId = ''; + /** + * @generated from field: uint32 output_character_count = 8; + */ + outputCharacterCount = 0; + /** + * Number of seconds to wait for command completion. + * + * @generated from field: uint32 wait_duration_seconds = 10; + */ + waitDurationSeconds = 0; + /** + * Output + * + * @generated from field: exa.cortex_pb.CortexStepStatus status = 2; + */ + status = CortexStepStatus.UNSPECIFIED; + /** + * Full output of the command at this point. Note that for very large outputs, + * this may be truncated. + * + * @generated from field: string combined = 9; + */ + combined = ''; + /** + * Delta output since previous CommandStatus. Note that for very large + * outputs, this may be truncated. Will be unset if no previous command status + * to compare to. + * + * @generated from field: optional string delta = 12; + */ + delta; + /** + * Will be unset if the exit code cannot be determined. + * + * @generated from field: optional int32 exit_code = 5; + */ + exitCode; + /** + * @generated from field: exa.cortex_pb.CortexErrorDetails error = 6; + */ + error; + /** + * Number of seconds waited. + * + * @generated from field: uint32 waited_duration_seconds = 11; + */ + waitedDurationSeconds = 0; + /** + * Deprecated fields. + * + * @generated from field: string stdout = 3 [deprecated = true]; + * @deprecated + */ + stdout = ''; + /** + * @generated from field: string stderr = 4 [deprecated = true]; + * @deprecated + */ + stderr = ''; + /** + * @generated from field: exa.cortex_pb.CommandOutputPriority output_priority = 7 [deprecated = true]; + * @deprecated + */ + outputPriority = CommandOutputPriority.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCommandStatus'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'command_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'output_character_count', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 10, + name: 'wait_duration_seconds', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(CortexStepStatus), + }, + { + no: 9, + name: 'combined', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 12, name: 'delta', kind: 'scalar', T: 9, opt: true }, + { no: 5, name: 'exit_code', kind: 'scalar', T: 5, opt: true }, + { no: 6, name: 'error', kind: 'message', T: CortexErrorDetails }, + { + no: 11, + name: 'waited_duration_seconds', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'stdout', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'stderr', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'output_priority', + kind: 'enum', + T: proto3.getEnumType(CommandOutputPriority), + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCommandStatus().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepCommandStatus().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCommandStatus().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCommandStatus, a, b); + } +}; +var CortexMemory = class _CortexMemory extends Message { + /** + * @generated from field: string memory_id = 1; + */ + memoryId = ''; + /** + * A short title for the memory, only used when Cascade generates memories + * + * @generated from field: string title = 6; + */ + title = ''; + /** + * @generated from field: exa.cortex_pb.CortexMemoryMetadata metadata = 2; + */ + metadata; + /** + * Whether the memory is generated by a user or cascade + * + * @generated from field: exa.cortex_pb.CortexMemorySource source = 3; + */ + source = CortexMemorySource.UNSPECIFIED; + /** + * Global scope vs. Local (workspace) scope + * + * @generated from field: exa.cortex_pb.CortexMemoryScope scope = 4; + */ + scope; + /** + * @generated from oneof exa.cortex_pb.CortexMemory.memory + */ + memory = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexMemory'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'memory_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'metadata', kind: 'message', T: CortexMemoryMetadata }, + { + no: 3, + name: 'source', + kind: 'enum', + T: proto3.getEnumType(CortexMemorySource), + }, + { no: 4, name: 'scope', kind: 'message', T: CortexMemoryScope }, + { + no: 5, + name: 'text_memory', + kind: 'message', + T: CortexMemoryText, + oneof: 'memory', + }, + ]); + static fromBinary(bytes, options) { + return new _CortexMemory().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexMemory().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexMemory().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexMemory, a, b); + } +}; +var CortexMemoryMetadata = class _CortexMemoryMetadata extends Message { + /** + * @generated from field: google.protobuf.Timestamp created_at = 1; + */ + createdAt; + /** + * last time the memory was modified + * + * @generated from field: google.protobuf.Timestamp last_modified = 2; + */ + lastModified; + /** + * last time the memory was retrieved + * + * @generated from field: google.protobuf.Timestamp last_accessed = 3; + */ + lastAccessed; + /** + * @generated from field: repeated string tags = 4; + */ + tags = []; + /** + * Whether the memory was triggered by a user action + * Only relevant for Cascade generated memories + * + * @generated from field: bool user_triggered = 5; + */ + userTriggered = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexMemoryMetadata'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'created_at', kind: 'message', T: Timestamp }, + { no: 2, name: 'last_modified', kind: 'message', T: Timestamp }, + { no: 3, name: 'last_accessed', kind: 'message', T: Timestamp }, + { no: 4, name: 'tags', kind: 'scalar', T: 9, repeated: true }, + { + no: 5, + name: 'user_triggered', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexMemoryMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexMemoryMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexMemoryMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexMemoryMetadata, a, b); + } +}; +var CortexMemoryText = class _CortexMemoryText extends Message { + /** + * @generated from field: string content = 1; + */ + content = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexMemoryText'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexMemoryText().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexMemoryText().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexMemoryText().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexMemoryText, a, b); + } +}; +var CortexMemoryScope = class _CortexMemoryScope extends Message { + /** + * @generated from oneof exa.cortex_pb.CortexMemoryScope.scope + */ + scope = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexMemoryScope'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'global_scope', + kind: 'message', + T: CortexMemoryGlobalScope, + oneof: 'scope', + }, + { + no: 2, + name: 'local_scope', + kind: 'message', + T: CortexMemoryLocalScope, + oneof: 'scope', + }, + { + no: 3, + name: 'all_scope', + kind: 'message', + T: CortexMemoryAllScope, + oneof: 'scope', + }, + { + no: 4, + name: 'project_scope', + kind: 'message', + T: CortexMemoryProjectScope, + oneof: 'scope', + }, + ]); + static fromBinary(bytes, options) { + return new _CortexMemoryScope().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexMemoryScope().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexMemoryScope().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexMemoryScope, a, b); + } +}; +var CortexMemoryGlobalScope = class _CortexMemoryGlobalScope extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexMemoryGlobalScope'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CortexMemoryGlobalScope().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexMemoryGlobalScope().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexMemoryGlobalScope().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexMemoryGlobalScope, a, b); + } +}; +var CortexMemoryLocalScope = class _CortexMemoryLocalScope extends Message { + /** + * @generated from field: repeated string corpus_names = 2; + */ + corpusNames = []; + /** + * only used by user-defined local rules + * + * @generated from field: repeated string base_dir_uris = 3; + */ + baseDirUris = []; + /** + * deprecated + * + * @generated from field: string repo_base_dir_uri = 1 [deprecated = true]; + * @deprecated + */ + repoBaseDirUri = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexMemoryLocalScope'; + static fields = proto3.util.newFieldList(() => [ + { no: 2, name: 'corpus_names', kind: 'scalar', T: 9, repeated: true }, + { no: 3, name: 'base_dir_uris', kind: 'scalar', T: 9, repeated: true }, + { + no: 1, + name: 'repo_base_dir_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexMemoryLocalScope().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexMemoryLocalScope().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexMemoryLocalScope().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexMemoryLocalScope, a, b); + } +}; +var CortexMemoryAllScope = class _CortexMemoryAllScope extends Message { + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexMemoryAllScope'; + static fields = proto3.util.newFieldList(() => []); + static fromBinary(bytes, options) { + return new _CortexMemoryAllScope().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexMemoryAllScope().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexMemoryAllScope().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexMemoryAllScope, a, b); + } +}; +var CortexMemoryProjectScope = class _CortexMemoryProjectScope extends Message { + /** + * @generated from field: string file_path = 1; + */ + filePath = ''; + /** + * @generated from field: string absolute_file_path = 7; + */ + absoluteFilePath = ''; + /** + * @generated from field: repeated string base_dir_uris = 2; + */ + baseDirUris = []; + /** + * @generated from field: repeated string corpus_names = 3; + */ + corpusNames = []; + /** + * @generated from field: exa.cortex_pb.CortexMemoryTrigger trigger = 4; + */ + trigger = CortexMemoryTrigger.UNSPECIFIED; + /** + * @generated from field: string description = 5; + */ + description = ''; + /** + * @generated from field: repeated string globs = 6; + */ + globs = []; + /** + * To determine which memories to show first, higher priority = show earlier + * + * @generated from field: int32 priority = 8; + */ + priority = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexMemoryProjectScope'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'file_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'absolute_file_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'base_dir_uris', kind: 'scalar', T: 9, repeated: true }, + { no: 3, name: 'corpus_names', kind: 'scalar', T: 9, repeated: true }, + { + no: 4, + name: 'trigger', + kind: 'enum', + T: proto3.getEnumType(CortexMemoryTrigger), + }, + { + no: 5, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 6, name: 'globs', kind: 'scalar', T: 9, repeated: true }, + { + no: 8, + name: 'priority', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexMemoryProjectScope().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexMemoryProjectScope().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexMemoryProjectScope().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexMemoryProjectScope, a, b); + } +}; +var CortexStepMemory = class _CortexStepMemory extends Message { + /** + * Inputs + * Memory id being updated. Empty string for new memory. + * + * @generated from field: string memory_id = 1; + */ + memoryId = ''; + /** + * Updated version of the memory, nil if deleted. + * + * @generated from field: exa.cortex_pb.CortexMemory memory = 2; + */ + memory; + /** + * The previous state of the memory, if it was deleted or updated. + * Only populated if the memory action was DELETE or UPDATE. + * + * @generated from field: exa.cortex_pb.CortexMemory prev_memory = 4; + */ + prevMemory; + /** + * Action to take on the memory. + * + * @generated from field: exa.cortex_pb.MemoryActionType action = 3; + */ + action = MemoryActionType.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepMemory'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'memory_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'memory', kind: 'message', T: CortexMemory }, + { no: 4, name: 'prev_memory', kind: 'message', T: CortexMemory }, + { + no: 3, + name: 'action', + kind: 'enum', + T: proto3.getEnumType(MemoryActionType), + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepMemory().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepMemory().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepMemory().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepMemory, a, b); + } +}; +var CortexStepRetrieveMemory = class _CortexStepRetrieveMemory extends Message { + /** + * INPUTS + * Run the subagent that retrieves relevant memories + * + * @generated from field: bool run_subagent = 1; + */ + runSubagent = false; + /** + * automatically append user memories to the retrieved memories + * + * @generated from field: bool add_user_memories = 8; + */ + addUserMemories = false; + /** + * OUTPUTS + * A summary of retrieved Cascade memories to show to Cascade + * + * @generated from field: string cascade_memory_summary = 2; + */ + cascadeMemorySummary = ''; + /** + * A summary of User memories to show Cascade + * + * @generated from field: string user_memory_summary = 3; + */ + userMemorySummary = ''; + /** + * The reason why these memories were retrieved + * + * @generated from field: string reason = 4; + */ + reason = ''; + /** + * Add the reason into the chat conversation. + * + * @generated from field: bool show_reason = 5; + */ + showReason = false; + /** + * Memories that are retrieved during this step + * + * @generated from field: repeated exa.cortex_pb.CortexMemory retrieved_memories = 6; + */ + retrievedMemories = []; + /** + * Deprecated + * + * @generated from field: bool blocking = 7 [deprecated = true]; + * @deprecated + */ + blocking = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepRetrieveMemory'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'run_subagent', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 8, + name: 'add_user_memories', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 2, + name: 'cascade_memory_summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'user_memory_summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'reason', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'show_reason', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'retrieved_memories', + kind: 'message', + T: CortexMemory, + repeated: true, + }, + { + no: 7, + name: 'blocking', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepRetrieveMemory().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepRetrieveMemory().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepRetrieveMemory().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepRetrieveMemory, a, b); + } +}; +var MemoryConfig = class _MemoryConfig extends Message { + /** + * Model used by the subagent to retrieve memories + * + * @generated from field: exa.codeium_common_pb.Model memory_model = 1; + */ + memoryModel = Model.UNSPECIFIED; + /** + * Number of checkpoints to include in the chat conversation + * used to provide context for memory retrieval + * + * @generated from field: uint32 num_checkpoints_for_context = 5; + */ + numCheckpointsForContext = 0; + /** + * The memory subagent will consider the num_memories_to_consider + * most recently accessed Cascade memories (global + local), when + * selecting which ones to present to the main agent. + * Set to -1 to consider all memories + * + * @generated from field: int32 num_memories_to_consider = 3; + */ + numMemoriesToConsider = 0; + /** + * Max number of global Cascade memories that can be stored on disk + * Set to -1 to not limit the number of global Cascade memories + * + * @generated from field: int32 max_global_cascade_memories = 4; + */ + maxGlobalCascadeMemories = 0; + /** + * If true, condenses input trajectory to a single user message, instead of + * representing as a whole conversation. + * + * @generated from field: optional bool condense_input_trajectory = 6; + */ + condenseInputTrajectory; + /** + * Inject user memories into the system prompt, but not Cascade's memories + * + * @generated from field: optional bool add_user_memories_to_system_prompt = 7; + */ + addUserMemoriesToSystemPrompt; + /** + * Deprecated + * The MemoryToolConfig's ForceDisable is now the global control for memories + * + * @generated from field: optional bool enabled = 2 [deprecated = true]; + * @deprecated + */ + enabled; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.MemoryConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'memory_model', kind: 'enum', T: proto3.getEnumType(Model) }, + { + no: 5, + name: 'num_checkpoints_for_context', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'num_memories_to_consider', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'max_global_cascade_memories', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'condense_input_trajectory', + kind: 'scalar', + T: 8, + opt: true, + }, + { + no: 7, + name: 'add_user_memories_to_system_prompt', + kind: 'scalar', + T: 8, + opt: true, + }, + { no: 2, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _MemoryConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _MemoryConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _MemoryConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_MemoryConfig, a, b); + } +}; +var ViewedFileTrackerConfig = class _ViewedFileTrackerConfig extends Message { + /** + * WARNING(nmoy): These can only be set to 0 by experiment config if they are + * optional. For now only max_steps_per_checkpoint is optional. + * + * @generated from field: optional uint32 max_steps_per_checkpoint = 1; + */ + maxStepsPerCheckpoint; + /** + * @generated from field: uint32 max_files_in_prompt = 2; + */ + maxFilesInPrompt = 0; + /** + * @generated from field: uint32 max_lines_per_file_in_prompt = 3; + */ + maxLinesPerFileInPrompt = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ViewedFileTrackerConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_steps_per_checkpoint', + kind: 'scalar', + T: 13, + opt: true, + }, + { + no: 2, + name: 'max_files_in_prompt', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'max_lines_per_file_in_prompt', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ViewedFileTrackerConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ViewedFileTrackerConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ViewedFileTrackerConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ViewedFileTrackerConfig, a, b); + } +}; +var CodeStepCreationOptions = class _CodeStepCreationOptions extends Message { + /** + * @generated from field: int64 diff_block_separation_threshold = 1; + */ + diffBlockSeparationThreshold = protoInt64.zero; + /** + * @generated from field: bool handle_deletions = 2; + */ + handleDeletions = false; + /** + * @generated from field: bool handle_creations = 3; + */ + handleCreations = false; + /** + * @generated from field: optional bool include_original_content = 4; + */ + includeOriginalContent; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CodeStepCreationOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'diff_block_separation_threshold', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + { + no: 2, + name: 'handle_deletions', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'handle_creations', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'include_original_content', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CodeStepCreationOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeStepCreationOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeStepCreationOptions().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeStepCreationOptions, a, b); + } +}; +var BrainUpdateStepCreationOptions = class _BrainUpdateStepCreationOptions extends Message { + /** + * @generated from field: string entry_id_prefix = 1; + */ + entryIdPrefix = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrainUpdateStepCreationOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'entry_id_prefix', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _BrainUpdateStepCreationOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrainUpdateStepCreationOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrainUpdateStepCreationOptions().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_BrainUpdateStepCreationOptions, a, b); + } +}; +var ViewFileStepCreationOptions = class _ViewFileStepCreationOptions extends Message { + /** + * @generated from field: bool condition_on_edit_step = 1; + */ + conditionOnEditStep = false; + /** + * @generated from field: optional bool include_raw_content = 2; + */ + includeRawContent; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ViewFileStepCreationOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'condition_on_edit_step', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 2, name: 'include_raw_content', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _ViewFileStepCreationOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ViewFileStepCreationOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ViewFileStepCreationOptions().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ViewFileStepCreationOptions, a, b); + } +}; +var UserGrepStepCreationOptions = class _UserGrepStepCreationOptions extends Message { + /** + * @generated from field: uint32 num_search_events = 1; + */ + numSearchEvents = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.UserGrepStepCreationOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'num_search_events', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _UserGrepStepCreationOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _UserGrepStepCreationOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _UserGrepStepCreationOptions().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_UserGrepStepCreationOptions, a, b); + } +}; +var RunCommandStepCreationOptions = class _RunCommandStepCreationOptions extends Message { + /** + * Maximum number of commands to consider. + * + * @generated from field: uint32 max_commands = 1; + */ + maxCommands = 0; + /** + * Maximum age of a command to consider. + * + * @generated from field: google.protobuf.Duration max_command_age = 2; + */ + maxCommandAge; + /** + * Maximum bytes of output to keep per command. + * + * @generated from field: uint32 per_command_max_bytes_output = 3; + */ + perCommandMaxBytesOutput = 0; + /** + * Maximum total bytes of output to keep across all commands. + * + * @generated from field: uint32 total_max_bytes_output = 4; + */ + totalMaxBytesOutput = 0; + /** + * Whether to include commands that are still running. + * + * @generated from field: optional bool include_running = 5; + */ + includeRunning; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.RunCommandStepCreationOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_commands', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 2, name: 'max_command_age', kind: 'message', T: Duration }, + { + no: 3, + name: 'per_command_max_bytes_output', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'total_max_bytes_output', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { no: 5, name: 'include_running', kind: 'scalar', T: 8, opt: true }, + ]); + static fromBinary(bytes, options) { + return new _RunCommandStepCreationOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RunCommandStepCreationOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RunCommandStepCreationOptions().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_RunCommandStepCreationOptions, a, b); + } +}; +var LintDiffStepCreationOptions = class _LintDiffStepCreationOptions extends Message { + /** + * Maximum number of lint changes to add to trajectory at once + * + * @generated from field: uint32 max_lint_inserts = 1; + */ + maxLintInserts = 0; + /** + * Minimum time a lint should exist before adding to trajectory, in ms + * + * @generated from field: uint32 min_required_lint_duration = 2; + */ + minRequiredLintDuration = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.LintDiffStepCreationOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_lint_inserts', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'min_required_lint_duration', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _LintDiffStepCreationOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _LintDiffStepCreationOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _LintDiffStepCreationOptions().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_LintDiffStepCreationOptions, a, b); + } +}; +var BrowserStepCreationOptions = class _BrowserStepCreationOptions extends Message { + /** + * Maximum number of browser interactions to consider. + * + * @generated from field: uint32 max_browser_interactions = 1; + */ + maxBrowserInteractions = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.BrowserStepCreationOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_browser_interactions', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _BrowserStepCreationOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _BrowserStepCreationOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _BrowserStepCreationOptions().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_BrowserStepCreationOptions, a, b); + } +}; +var SnapshotToStepsOptions = class _SnapshotToStepsOptions extends Message { + /** + * @generated from field: exa.cortex_pb.CodeStepCreationOptions code_step_creation_options = 1; + */ + codeStepCreationOptions; + /** + * @generated from field: exa.cortex_pb.ViewFileStepCreationOptions view_file_step_creation_options = 2; + */ + viewFileStepCreationOptions; + /** + * @generated from field: exa.cortex_pb.ViewedFileTrackerConfig viewed_file_tracker_config = 3; + */ + viewedFileTrackerConfig; + /** + * Note: because of how proto merge handles repeated fields, this can never be + * overwritten by an experiment override -- only appended. + * + * @generated from field: repeated exa.cortex_pb.CortexStepType step_type_allow_list = 4; + */ + stepTypeAllowList = []; + /** + * @generated from field: exa.cortex_pb.UserGrepStepCreationOptions user_grep_step_creation_options = 5; + */ + userGrepStepCreationOptions; + /** + * @generated from field: exa.cortex_pb.RunCommandStepCreationOptions run_command_step_creation_options = 6; + */ + runCommandStepCreationOptions; + /** + * @generated from field: exa.cortex_pb.LintDiffStepCreationOptions lint_diff_step_creation_options = 7; + */ + lintDiffStepCreationOptions; + /** + * @generated from field: exa.cortex_pb.BrowserStepCreationOptions browser_step_creation_options = 9; + */ + browserStepCreationOptions; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.SnapshotToStepsOptions'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'code_step_creation_options', + kind: 'message', + T: CodeStepCreationOptions, + }, + { + no: 2, + name: 'view_file_step_creation_options', + kind: 'message', + T: ViewFileStepCreationOptions, + }, + { + no: 3, + name: 'viewed_file_tracker_config', + kind: 'message', + T: ViewedFileTrackerConfig, + }, + { + no: 4, + name: 'step_type_allow_list', + kind: 'enum', + T: proto3.getEnumType(CortexStepType), + repeated: true, + }, + { + no: 5, + name: 'user_grep_step_creation_options', + kind: 'message', + T: UserGrepStepCreationOptions, + }, + { + no: 6, + name: 'run_command_step_creation_options', + kind: 'message', + T: RunCommandStepCreationOptions, + }, + { + no: 7, + name: 'lint_diff_step_creation_options', + kind: 'message', + T: LintDiffStepCreationOptions, + }, + { + no: 9, + name: 'browser_step_creation_options', + kind: 'message', + T: BrowserStepCreationOptions, + }, + ]); + static fromBinary(bytes, options) { + return new _SnapshotToStepsOptions().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _SnapshotToStepsOptions().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _SnapshotToStepsOptions().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_SnapshotToStepsOptions, a, b); + } +}; +var CortexStepPostPrReview = class _CortexStepPostPrReview extends Message { + /** + * The comment body + * + * @generated from field: string body = 1; + */ + body = ''; + /** + * The SHA of the commit needing a comment + * + * @generated from field: string commit_id = 2; + */ + commitId = ''; + /** + * The relative path to the file that necessitates a comment + * + * @generated from field: string path = 3; + */ + path = ''; + /** + * The side of the diff that the PR's changes appear on + * + * @generated from field: string side = 4; + */ + side = ''; + /** + * The first line in the PR diff that a multi-line comment applies to. + * + * @generated from field: int32 start_line = 5; + */ + startLine = 0; + /** + * The line, or the last line of the blob if multi-line, of the blob in PR + * diff that the comment applies to. + * + * @generated from field: int32 end_line = 6; + */ + endLine = 0; + /** + * The category of the comment. We set to "negative" during eval to flag + * negative comments. + * + * @generated from field: string category = 7; + */ + category = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepPostPrReview'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'body', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'commit_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'side', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'start_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'end_line', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 7, + name: 'category', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepPostPrReview().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepPostPrReview().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepPostPrReview().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepPostPrReview, a, b); + } +}; +var McpServerSpec = class _McpServerSpec extends Message { + /** + * @generated from field: string server_name = 1; + */ + serverName = ''; + /** + * @generated from field: string command = 2; + */ + command = ''; + /** + * @generated from field: repeated string args = 3; + */ + args = []; + /** + * @generated from field: map env = 4; + */ + env = {}; + /** + * URL of the server for SSE. Ignores command, args, env if provided. + * + * @generated from field: string server_url = 6; + */ + serverUrl = ''; + /** + * @generated from field: bool disabled = 7; + */ + disabled = false; + /** + * The tools available to the model include enabled tools (or all tools if no + * enabled tools are specified) minus disabled tools. + * + * @generated from field: repeated string disabled_tools = 8; + */ + disabledTools = []; + /** + * @generated from field: repeated string enabled_tools = 10; + */ + enabledTools = []; + /** + * @generated from field: map headers = 9; + */ + headers = {}; + /** + * Server's index in config when sorted by server_name + * + * @generated from field: uint32 server_index = 5 [deprecated = true]; + * @deprecated + */ + serverIndex = 0; + /** + * If true, tool names will not be prefixed with mcp_{server_name}_ + * This allows MCP tools to appear as native tools. + * + * @generated from field: bool skip_tool_name_prefix = 11; + */ + skipToolNamePrefix = false; + /** + * If true, tool descriptions will not be prefixed with + * "This is a tool from the {server_name} MCP server." + * + * @generated from field: bool skip_tool_description_prefix = 12; + */ + skipToolDescriptionPrefix = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.McpServerSpec'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'server_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'command', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'args', kind: 'scalar', T: 9, repeated: true }, + { + no: 4, + name: 'env', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { + no: 6, + name: 'server_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'disabled', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 8, name: 'disabled_tools', kind: 'scalar', T: 9, repeated: true }, + { no: 10, name: 'enabled_tools', kind: 'scalar', T: 9, repeated: true }, + { + no: 9, + name: 'headers', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { + no: 5, + name: 'server_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 11, + name: 'skip_tool_name_prefix', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 12, + name: 'skip_tool_description_prefix', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _McpServerSpec().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpServerSpec().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpServerSpec().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpServerSpec, a, b); + } +}; +var McpServerInfo = class _McpServerInfo extends Message { + /** + * @generated from field: string name = 1; + */ + name = ''; + /** + * @generated from field: string version = 2; + */ + version = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.McpServerInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'version', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _McpServerInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpServerInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpServerInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpServerInfo, a, b); + } +}; +var StepRenderInfo = class _StepRenderInfo extends Message { + /** + * title to display for the tool result. + * + * @generated from field: string title = 1; + */ + title = ''; + /** + * markdown content to render. + * + * @generated from field: string markdown = 2; + */ + markdown = ''; + /** + * Optional metadata for additional context. + * + * @generated from field: map metadata = 3; + */ + metadata = {}; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.StepRenderInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'markdown', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'metadata', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + ]); + static fromBinary(bytes, options) { + return new _StepRenderInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _StepRenderInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _StepRenderInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_StepRenderInfo, a, b); + } +}; +var CortexStepMcpTool = class _CortexStepMcpTool extends Message { + /** + * Inputs + * + * @generated from field: string server_name = 1; + */ + serverName = ''; + /** + * @generated from field: exa.codeium_common_pb.ChatToolCall tool_call = 2; + */ + toolCall; + /** + * Info directly from the MCP server. + * + * @generated from field: exa.cortex_pb.McpServerInfo server_info = 4; + */ + serverInfo; + /** + * Outputs + * + * @generated from oneof exa.cortex_pb.CortexStepMcpTool.result + */ + result = { case: void 0 }; + /** + * Deprecated: Use media instead + * + * @generated from field: repeated exa.codeium_common_pb.ImageData images = 5 [deprecated = true]; + * @deprecated + */ + images = []; + /** + * @generated from field: repeated exa.codeium_common_pb.Media media = 6; + */ + media = []; + /** + * @generated from field: bool user_rejected = 7; + */ + userRejected = false; + /** + * Optional rendering information for custom UI display. + * + * @generated from field: exa.cortex_pb.StepRenderInfo render_info = 9; + */ + renderInfo; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepMcpTool'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'server_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'tool_call', kind: 'message', T: ChatToolCall }, + { no: 4, name: 'server_info', kind: 'message', T: McpServerInfo }, + { no: 3, name: 'result_string', kind: 'scalar', T: 9, oneof: 'result' }, + { no: 8, name: 'result_uri', kind: 'scalar', T: 9, oneof: 'result' }, + { no: 5, name: 'images', kind: 'message', T: ImageData, repeated: true }, + { no: 6, name: 'media', kind: 'message', T: Media, repeated: true }, + { + no: 7, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 9, name: 'render_info', kind: 'message', T: StepRenderInfo }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepMcpTool().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepMcpTool().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepMcpTool().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepMcpTool, a, b); + } +}; +var McpResource = class _McpResource extends Message { + /** + * @generated from field: string uri = 1; + */ + uri = ''; + /** + * @generated from field: string name = 2; + */ + name = ''; + /** + * @generated from field: string description = 3; + */ + description = ''; + /** + * @generated from field: string mime_type = 4; + */ + mimeType = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.McpResource'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'mime_type', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _McpResource().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpResource().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpResource().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpResource, a, b); + } +}; +var McpResourceContent = class _McpResourceContent extends Message { + /** + * @generated from field: string uri = 1; + */ + uri = ''; + /** + * @generated from oneof exa.cortex_pb.McpResourceContent.data + */ + data = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.McpResourceContent'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'text', kind: 'message', T: TextData, oneof: 'data' }, + { no: 3, name: 'image', kind: 'message', T: ImageData, oneof: 'data' }, + { no: 4, name: 'media_content', kind: 'message', T: Media, oneof: 'data' }, + ]); + static fromBinary(bytes, options) { + return new _McpResourceContent().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpResourceContent().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpResourceContent().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpResourceContent, a, b); + } +}; +var CortexStepListResources = class _CortexStepListResources extends Message { + /** + * Inputs + * + * @generated from field: string server_name = 1; + */ + serverName = ''; + /** + * Used for pagination + * + * @generated from field: optional string cursor = 2; + */ + cursor; + /** + * Outputs + * + * @generated from field: repeated exa.cortex_pb.McpResource resources = 3; + */ + resources = []; + /** + * @generated from field: string next_cursor = 4; + */ + nextCursor = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepListResources'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'server_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'cursor', kind: 'scalar', T: 9, opt: true }, + { + no: 3, + name: 'resources', + kind: 'message', + T: McpResource, + repeated: true, + }, + { + no: 4, + name: 'next_cursor', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepListResources().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepListResources().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepListResources().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepListResources, a, b); + } +}; +var CortexStepReadResource = class _CortexStepReadResource extends Message { + /** + * Inputs + * + * @generated from field: string server_name = 1; + */ + serverName = ''; + /** + * @generated from field: string uri = 2; + */ + uri = ''; + /** + * Outputs + * + * @generated from field: repeated exa.cortex_pb.McpResourceContent contents = 3; + */ + contents = []; + /** + * @generated from field: bool skipped_non_image_binary_content = 4; + */ + skippedNonImageBinaryContent = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepReadResource'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'server_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'contents', + kind: 'message', + T: McpResourceContent, + repeated: true, + }, + { + no: 4, + name: 'skipped_non_image_binary_content', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepReadResource().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepReadResource().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepReadResource().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepReadResource, a, b); + } +}; +var CortexStepArtifactSummary = class _CortexStepArtifactSummary extends Message { + /** + * Outputs + * + * @generated from field: string summary = 1; + */ + summary = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepArtifactSummary'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepArtifactSummary().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepArtifactSummary().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepArtifactSummary().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepArtifactSummary, a, b); + } +}; +var CortexStepManagerFeedback = class _CortexStepManagerFeedback extends Message { + /** + * Outputs + * + * @generated from field: exa.cortex_pb.CortexStepManagerFeedbackStatus status = 1; + */ + status = CortexStepManagerFeedbackStatus.UNSPECIFIED; + /** + * @generated from field: string feedback = 2; + */ + feedback = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepManagerFeedback'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(CortexStepManagerFeedbackStatus), + }, + { + no: 2, + name: 'feedback', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepManagerFeedback().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepManagerFeedback().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepManagerFeedback().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepManagerFeedback, a, b); + } +}; +var CortexStepToolCallProposal = class _CortexStepToolCallProposal extends Message { + /** + * Inputs + * + * @generated from field: exa.codeium_common_pb.ChatToolCall tool_call = 1; + */ + toolCall; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepToolCallProposal'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'tool_call', kind: 'message', T: ChatToolCall }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepToolCallProposal().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepToolCallProposal().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepToolCallProposal().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepToolCallProposal, a, b); + } +}; +var CortexStepToolCallChoice = class _CortexStepToolCallChoice extends Message { + /** + * Inputs + * + * @generated from field: repeated exa.codeium_common_pb.ChatToolCall proposal_tool_calls = 1; + */ + proposalToolCalls = []; + /** + * Outputs + * + * @generated from field: uint32 choice = 2; + */ + choice = 0; + /** + * @generated from field: string reason = 3; + */ + reason = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepToolCallChoice'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'proposal_tool_calls', + kind: 'message', + T: ChatToolCall, + repeated: true, + }, + { + no: 2, + name: 'choice', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'reason', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepToolCallChoice().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepToolCallChoice().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepToolCallChoice().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepToolCallChoice, a, b); + } +}; +var CortexStepTrajectoryChoice = class _CortexStepTrajectoryChoice extends Message { + /** + * Inputs + * + * @generated from field: repeated string proposal_trajectory_ids = 1; + */ + proposalTrajectoryIds = []; + /** + * Outputs + * + * @generated from field: int32 choice = 2; + */ + choice = 0; + /** + * @generated from field: string reason = 3; + */ + reason = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepTrajectoryChoice'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'proposal_trajectory_ids', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 2, + name: 'choice', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'reason', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepTrajectoryChoice().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepTrajectoryChoice().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepTrajectoryChoice().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepTrajectoryChoice, a, b); + } +}; +var McpServerState = class _McpServerState extends Message { + /** + * @generated from field: exa.cortex_pb.McpServerSpec spec = 1; + */ + spec; + /** + * @generated from field: exa.cortex_pb.McpServerStatus status = 2; + */ + status = McpServerStatus.UNSPECIFIED; + /** + * @generated from field: string error = 3; + */ + error = ''; + /** + * @generated from field: repeated exa.chat_pb.ChatToolDefinition tools = 4; + */ + tools = []; + /** + * Index-matched with tools; if any tools are invalid, this will contain the + * error. + * + * @generated from field: repeated string tool_errors = 7; + */ + toolErrors = []; + /** + * Info directly from the MCP server. + * + * @generated from field: exa.cortex_pb.McpServerInfo server_info = 5; + */ + serverInfo; + /** + * @generated from field: string instructions = 6; + */ + instructions = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.McpServerState'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'spec', kind: 'message', T: McpServerSpec }, + { + no: 2, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(McpServerStatus), + }, + { + no: 3, + name: 'error', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'tools', + kind: 'message', + T: ChatToolDefinition, + repeated: true, + }, + { no: 7, name: 'tool_errors', kind: 'scalar', T: 9, repeated: true }, + { no: 5, name: 'server_info', kind: 'message', T: McpServerInfo }, + { + no: 6, + name: 'instructions', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _McpServerState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _McpServerState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _McpServerState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_McpServerState, a, b); + } +}; +var TrajectoryJudgeConfig = class _TrajectoryJudgeConfig extends Message { + /** + * If , truncates all non-input trajectories to be this long before + * judging. 0 means no truncation. + * + * @generated from field: int32 max_steps_to_judge = 1; + */ + maxStepsToJudge = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TrajectoryJudgeConfig'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'max_steps_to_judge', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _TrajectoryJudgeConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TrajectoryJudgeConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TrajectoryJudgeConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TrajectoryJudgeConfig, a, b); + } +}; +var CortexStepViewFileOutline = class _CortexStepViewFileOutline extends Message { + /** + * INPUTS + * + * @generated from field: string absolute_path_uri = 1; + */ + absolutePathUri = ''; + /** + * For pagination of results. + * + * @generated from field: uint32 cci_offset = 2; + */ + cciOffset = 0; + /** + * OUTPUTS + * Number of ccis is truncated based on config. This includes all ccis that + * were successfully converted to outline items. + * + * @generated from field: repeated exa.codeium_common_pb.CodeContextItem ccis = 3; + */ + ccis = []; + /** + * @generated from field: repeated string outline_items = 9; + */ + outlineItems = []; + /** + * This could be different from len(ccis) if any ccis failed. This number is + * >= len(ccis) for that reason. + * + * @generated from field: uint32 num_items_scanned = 10; + */ + numItemsScanned = 0; + /** + * @generated from field: uint32 total_cci_count = 4; + */ + totalCciCount = 0; + /** + * @generated from field: uint32 num_lines = 5; + */ + numLines = 0; + /** + * @generated from field: uint32 num_bytes = 6; + */ + numBytes = 0; + /** + * Only populated if offset is 0. May be truncated. + * + * @generated from field: string contents = 7; + */ + contents = ''; + /** + * @generated from field: uint32 content_lines_truncated = 8; + */ + contentLinesTruncated = 0; + /** + * Any rules that were triggered by this file outline view. + * + * @generated from field: string triggered_memories = 11; + */ + triggeredMemories = ''; + /** + * Full raw content of the file. Only stored for telemetry. + * + * @generated from field: string raw_content = 12; + */ + rawContent = ''; + /** + * @generated from field: exa.cortex_pb.FilePermissionInteractionSpec file_permission_request = 13; + */ + filePermissionRequest; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepViewFileOutline'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_path_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'cci_offset', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'ccis', + kind: 'message', + T: CodeContextItem, + repeated: true, + }, + { no: 9, name: 'outline_items', kind: 'scalar', T: 9, repeated: true }, + { + no: 10, + name: 'num_items_scanned', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'total_cci_count', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'num_lines', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 6, + name: 'num_bytes', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 7, + name: 'contents', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'content_lines_truncated', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 11, + name: 'triggered_memories', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 12, + name: 'raw_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 13, + name: 'file_permission_request', + kind: 'message', + T: FilePermissionInteractionSpec, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepViewFileOutline().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepViewFileOutline().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepViewFileOutline().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepViewFileOutline, a, b); + } +}; +var EphemeralMessagesConfig = class _EphemeralMessagesConfig extends Message { + /** + * @generated from field: optional bool enabled = 1; + */ + enabled; + /** + * Number of steps from the end of the trajectory + * to consider when applying heuristics + * + * @generated from field: uint32 num_steps = 2; + */ + numSteps = 0; + /** + * Prompts to inject, if a heuristic is triggered + * + * @generated from field: repeated exa.cortex_pb.HeuristicPrompt heuristic_prompts = 3; + */ + heuristicPrompts = []; + /** + * Sets whether ephemeral messages are persisted in the chat conversation + * + * @generated from field: exa.cortex_pb.EphemeralMessagePersistenceLevel persistence_level = 4; + */ + persistenceLevel = EphemeralMessagePersistenceLevel.UNSPECIFIED; + /** + * Optionally include parts of current browser page in ephemeral message. + * + * @generated from field: repeated exa.cortex_pb.BrowserEphemeralOption browser_ephemeral_options = 5; + */ + browserEphemeralOptions = []; + /** + * Proto.merge appends lists, so there's no way to exactly specify a list + * from the client without adding this field. This should only be used + * for local, dev-mode experiments. Prefer Unleash otherwise. + * See applyUnleashBrowserEphemeralMessageOverrideConfig. + * + * @generated from field: optional bool exclude_unleash_browser_ephemeral_options = 6; + */ + excludeUnleashBrowserEphemeralOptions; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.EphemeralMessagesConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { + no: 2, + name: 'num_steps', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'heuristic_prompts', + kind: 'message', + T: HeuristicPrompt, + repeated: true, + }, + { + no: 4, + name: 'persistence_level', + kind: 'enum', + T: proto3.getEnumType(EphemeralMessagePersistenceLevel), + }, + { + no: 5, + name: 'browser_ephemeral_options', + kind: 'enum', + T: proto3.getEnumType(BrowserEphemeralOption), + repeated: true, + }, + { + no: 6, + name: 'exclude_unleash_browser_ephemeral_options', + kind: 'scalar', + T: 8, + opt: true, + }, + ]); + static fromBinary(bytes, options) { + return new _EphemeralMessagesConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _EphemeralMessagesConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _EphemeralMessagesConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_EphemeralMessagesConfig, a, b); + } +}; +var HeuristicPrompt = class _HeuristicPrompt extends Message { + /** + * name of the heuristic + * + * @generated from field: string heuristic = 1; + */ + heuristic = ''; + /** + * injected prompt if heuristic is triggered + * + * @generated from field: string prompt = 2; + */ + prompt = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.HeuristicPrompt'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'heuristic', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _HeuristicPrompt().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _HeuristicPrompt().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _HeuristicPrompt().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_HeuristicPrompt, a, b); + } +}; +var RevertMetadata = class _RevertMetadata extends Message { + /** + * uris of any reverted file edits + * + * @generated from field: repeated string reverted_uris = 4; + */ + revertedUris = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.RevertMetadata'; + static fields = proto3.util.newFieldList(() => [ + { no: 4, name: 'reverted_uris', kind: 'scalar', T: 9, repeated: true }, + ]); + static fromBinary(bytes, options) { + return new _RevertMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _RevertMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _RevertMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_RevertMetadata, a, b); + } +}; +var TrajectoryPrefixMetadata = class _TrajectoryPrefixMetadata extends Message { + /** + * Metadata for getting a prefix of a trajectory based on a + * token limit. + * + * @generated from field: uint32 length = 1; + */ + length = 0; + /** + * @generated from field: uint32 tokens = 2; + */ + tokens = 0; + /** + * @generated from field: uint32 num_skipped = 3; + */ + numSkipped = 0; + /** + * @generated from field: uint32 num_truncated = 4; + */ + numTruncated = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TrajectoryPrefixMetadata'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'length', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 2, + name: 'tokens', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'num_skipped', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'num_truncated', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _TrajectoryPrefixMetadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TrajectoryPrefixMetadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TrajectoryPrefixMetadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TrajectoryPrefixMetadata, a, b); + } +}; +var CortexStepFindAllReferences = class _CortexStepFindAllReferences extends Message { + /** + * INPUTS + * + * @generated from field: string absolute_uri = 1; + */ + absoluteUri = ''; + /** + * Symbol to search for + * + * @generated from field: string symbol = 2; + */ + symbol = ''; + /** + * 0-indexed line number + * + * @generated from field: uint32 line = 3; + */ + line = 0; + /** + * 0-indexed occurrence index on the specified line; this is used to + * disambiguate cases where the specified symbol occurs multiple times on the + * same line + * + * @generated from field: uint32 occurrence_index = 4; + */ + occurrenceIndex = 0; + /** + * OUTPUTS + * + * @generated from field: repeated exa.codeium_common_pb.LspReference references = 5; + */ + references = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepFindAllReferences'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'symbol', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'line', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 4, + name: 'occurrence_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 5, + name: 'references', + kind: 'message', + T: LspReference, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepFindAllReferences().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepFindAllReferences().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepFindAllReferences().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepFindAllReferences, a, b); + } +}; +var CortexStepRunExtensionCode = class _CortexStepRunExtensionCode extends Message { + /** + * inputs + * + * @generated from field: string code = 1; + */ + code = ''; + /** + * @generated from field: string language = 2; + */ + language = ''; + /** + * Whether the model wants to auto-run this extension code. Only relevant if + * the user's setting allows model to decide. + * + * @generated from field: bool model_wants_auto_run = 6; + */ + modelWantsAutoRun = false; + /** + * @generated from field: string user_facing_explanation = 7; + */ + userFacingExplanation = ''; + /** + * outputs + * + * @generated from field: string output = 3; + */ + output = ''; + /** + * @generated from field: bool user_rejected = 4; + */ + userRejected = false; + /** + * @generated from field: exa.cortex_pb.RunExtensionCodeAutoRunDecision auto_run_decision = 5; + */ + autoRunDecision = RunExtensionCodeAutoRunDecision.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepRunExtensionCode'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'code', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'language', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'model_wants_auto_run', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'user_facing_explanation', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'output', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'auto_run_decision', + kind: 'enum', + T: proto3.getEnumType(RunExtensionCodeAutoRunDecision), + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepRunExtensionCode().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepRunExtensionCode().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepRunExtensionCode().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepRunExtensionCode, a, b); + } +}; +var CortexStepProposalFeedback = class _CortexStepProposalFeedback extends Message { + /** + * @generated from field: exa.cortex_pb.AcknowledgementType acknowledgement_type = 1; + */ + acknowledgementType = AcknowledgementType.UNSPECIFIED; + /** + * @generated from field: uint32 target_step_index = 2; + */ + targetStepIndex = 0; + /** + * @generated from oneof exa.cortex_pb.CortexStepProposalFeedback.target + */ + target = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepProposalFeedback'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'acknowledgement_type', + kind: 'enum', + T: proto3.getEnumType(AcknowledgementType), + }, + { + no: 2, + name: 'target_step_index', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + { + no: 3, + name: 'replacement_chunk', + kind: 'message', + T: ReplacementChunk, + oneof: 'target', + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepProposalFeedback().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepProposalFeedback().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepProposalFeedback().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepProposalFeedback, a, b); + } +}; +var TrajectoryDescription2 = class _TrajectoryDescription extends Message { + /** + * @generated from oneof exa.cortex_pb.TrajectoryDescription.description + */ + description = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TrajectoryDescription'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'cascade_conversation_title', + kind: 'scalar', + T: 9, + oneof: 'description', + }, + { + no: 2, + name: 'mainline_branch_name', + kind: 'scalar', + T: 9, + oneof: 'description', + }, + ]); + static fromBinary(bytes, options) { + return new _TrajectoryDescription().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TrajectoryDescription().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TrajectoryDescription().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TrajectoryDescription, a, b); + } +}; +var CortexStepTrajectorySearch = class _CortexStepTrajectorySearch extends Message { + /** + * INPUTS + * The ID of the trajectory to search. + * + * @generated from field: string id = 1; + */ + id = ''; + /** + * The search query string. If empty, the entire trajectory is retrieved. + * + * @generated from field: string query = 2; + */ + query = ''; + /** + * The type of the search + * + * @generated from field: exa.cortex_pb.TrajectorySearchIdType id_type = 3; + */ + idType = TrajectorySearchIdType.UNSPECIFIED; + /** + * OUTPUTS + * Scored output chunks + * + * @generated from field: repeated exa.context_module_pb.CciWithSubrangeWithRetrievalMetadata chunks = 4; + */ + chunks = []; + /** + * Description of the searched trajectory (e.g., conversation title or branch + * name). + * + * @generated from field: exa.cortex_pb.TrajectoryDescription trajectory_description = 5; + */ + trajectoryDescription; + /** + * Total number of chunks in the trajectory + * + * @generated from field: uint32 total_chunks = 6; + */ + totalChunks = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepTrajectorySearch'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'id_type', + kind: 'enum', + T: proto3.getEnumType(TrajectorySearchIdType), + }, + { + no: 4, + name: 'chunks', + kind: 'message', + T: CciWithSubrangeWithRetrievalMetadata, + repeated: true, + }, + { + no: 5, + name: 'trajectory_description', + kind: 'message', + T: TrajectoryDescription2, + }, + { + no: 6, + name: 'total_chunks', + kind: 'scalar', + T: 13, + /* ScalarType.UINT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepTrajectorySearch().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepTrajectorySearch().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepTrajectorySearch().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepTrajectorySearch, a, b); + } +}; +var CortexStepReadTerminal = class _CortexStepReadTerminal extends Message { + /** + * INPUTS + * The process ID of the terminal to read. + * + * @generated from field: string process_id = 1; + */ + processId = ''; + /** + * @generated from field: string name = 2; + */ + name = ''; + /** + * OUTPUTS + * The contents of the requested terminal (truncated to 4000 characters) + * + * @generated from field: string contents = 3; + */ + contents = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepReadTerminal'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'process_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'contents', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepReadTerminal().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepReadTerminal().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepReadTerminal().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepReadTerminal, a, b); + } +}; +var TaskResolutionOpenPr = class _TaskResolutionOpenPr extends Message { + /** + * @generated from field: string pr_title = 1; + */ + prTitle = ''; + /** + * @generated from field: string pr_body = 2; + */ + prBody = ''; + /** + * Github URL + * + * @generated from field: string pr_url = 3; + */ + prUrl = ''; + /** + * Whether a PR for the branch existed prior to this task resolution; in this + * case, the task resolution amounts to an update to that PR. + * + * @generated from field: bool existed_previously = 4; + */ + existedPreviously = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TaskResolutionOpenPr'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'pr_title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'pr_body', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'pr_url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'existed_previously', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _TaskResolutionOpenPr().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TaskResolutionOpenPr().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TaskResolutionOpenPr().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TaskResolutionOpenPr, a, b); + } +}; +var TaskResolution = class _TaskResolution extends Message { + /** + * @generated from oneof exa.cortex_pb.TaskResolution.resolution + */ + resolution = { case: void 0 }; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.TaskResolution'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'open_pr', + kind: 'message', + T: TaskResolutionOpenPr, + oneof: 'resolution', + }, + ]); + static fromBinary(bytes, options) { + return new _TaskResolution().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _TaskResolution().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _TaskResolution().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_TaskResolution, a, b); + } +}; +var CortexStepResolveTask = class _CortexStepResolveTask extends Message { + /** + * URI for the absolute path of the working directory for the task, i.e. repo + * root. + * + * @generated from field: string absolute_uri = 1; + */ + absoluteUri = ''; + /** + * A proposed title for the task. Suitable for e.g. a PR title, or a commit + * message. + * + * @generated from field: string title = 2; + */ + title = ''; + /** + * A proposed description of the task. Suitable for e.g. a PR description, or + * the extra message of a commit. + * + * @generated from field: string description = 3; + */ + description = ''; + /** + * Whether the user rejected the task resolution. + * + * @generated from field: bool user_rejected = 4; + */ + userRejected = false; + /** + * The resolution outcome of the task. + * + * @generated from field: exa.cortex_pb.TaskResolution resolution = 5; + */ + resolution; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepResolveTask'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'absolute_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 5, name: 'resolution', kind: 'message', T: TaskResolution }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepResolveTask().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepResolveTask().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepResolveTask().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepResolveTask, a, b); + } +}; +var CodeSearchMatch = class _CodeSearchMatch extends Message { + /** + * @generated from field: string snippet = 1; + */ + snippet = ''; + /** + * @generated from field: int32 line_number = 2; + */ + lineNumber = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CodeSearchMatch'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'snippet', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'line_number', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CodeSearchMatch().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeSearchMatch().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeSearchMatch().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeSearchMatch, a, b); + } +}; +var CodeSearchResults = class _CodeSearchResults extends Message { + /** + * @generated from field: string path = 1; + */ + path = ''; + /** + * @generated from field: repeated exa.cortex_pb.CodeSearchMatch matches = 4; + */ + matches = []; + /** + * @generated from field: string changelist = 5; + */ + changelist = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CodeSearchResults'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'matches', + kind: 'message', + T: CodeSearchMatch, + repeated: true, + }, + { + no: 5, + name: 'changelist', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CodeSearchResults().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeSearchResults().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeSearchResults().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeSearchResults, a, b); + } +}; +var CortexStepCodeSearch = class _CortexStepCodeSearch extends Message { + /** + * INPUTS + * + * @generated from field: string query = 1; + */ + query = ''; + /** + * @generated from field: bool only_paths = 6; + */ + onlyPaths = false; + /** + * @generated from field: bool allow_dirs = 7; + */ + allowDirs = false; + /** + * OUTPUTS + * + * @generated from field: repeated exa.cortex_pb.CodeSearchResults results = 5; + */ + results = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCodeSearch'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'only_paths', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 7, + name: 'allow_dirs', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'results', + kind: 'message', + T: CodeSearchResults, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCodeSearch().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepCodeSearch().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCodeSearch().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCodeSearch, a, b); + } +}; +var CortexStepBrowserInput = class _CortexStepBrowserInput extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * @generated from field: int32 index = 2; + */ + index = 0; + /** + * @generated from field: string text = 3; + */ + text = ''; + /** + * @generated from field: bool press_enter = 4; + */ + pressEnter = false; + /** + * @generated from field: bool clear_text = 5; + */ + clearText = false; + /** + * Outputs + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 6; + */ + pageMetadata; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 7; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserInput'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'press_enter', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'clear_text', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 6, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 7, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserInput().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserInput().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserInput().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserInput, a, b); + } +}; +var CortexStepBrowserMoveMouse = class _CortexStepBrowserMoveMouse extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * @generated from field: int32 x = 2; + */ + x = 0; + /** + * @generated from field: int32 y = 3; + */ + y = 0; + /** + * Outputs + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 6; + */ + pageMetadata; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 7; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserMoveMouse'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'x', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'y', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { no: 6, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 7, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserMoveMouse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserMoveMouse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserMoveMouse().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserMoveMouse, a, b); + } +}; +var CortexStepBrowserSelectOption = class _CortexStepBrowserSelectOption extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * @generated from field: int32 index = 2; + */ + index = 0; + /** + * @generated from field: string value = 3; + */ + value = ''; + /** + * Outputs + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 6; + */ + pageMetadata; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 7; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserSelectOption'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'value', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 6, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 7, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserSelectOption().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserSelectOption().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserSelectOption().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserSelectOption, a, b); + } +}; +var CortexStepBrowserScroll = class _CortexStepBrowserScroll extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * @generated from field: exa.browser_pb.ScrollDirection direction = 2; + */ + direction = ScrollDirection.UNSPECIFIED; + /** + * @generated from field: bool scroll_to_end = 3; + */ + scrollToEnd = false; + /** + * @generated from field: bool scroll_by_element_index = 4; + */ + scrollByElementIndex = false; + /** + * @generated from field: int32 element_index = 5; + */ + elementIndex = 0; + /** + * Outputs + * + * @generated from field: int32 pixels_scrolled_x = 6; + */ + pixelsScrolledX = 0; + /** + * @generated from field: int32 pixels_scrolled_y = 7; + */ + pixelsScrolledY = 0; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 8; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserScroll'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'direction', + kind: 'enum', + T: proto3.getEnumType(ScrollDirection), + }, + { + no: 3, + name: 'scroll_to_end', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'scroll_by_element_index', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 5, + name: 'element_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'pixels_scrolled_x', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 7, + name: 'pixels_scrolled_y', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 8, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserScroll().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserScroll().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserScroll().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserScroll, a, b); + } +}; +var CortexStepBrowserScrollUp = class _CortexStepBrowserScrollUp extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * @generated from field: bool scroll_to_end = 2; + */ + scrollToEnd = false; + /** + * Optional flags for scrolling inside specific elements + * + * if true, scroll to the specific element + * + * @generated from field: bool scroll_by_element_index = 3; + */ + scrollByElementIndex = false; + /** + * Index of the element to scroll to + * + * @generated from field: int32 element_index = 4; + */ + elementIndex = 0; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 5; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserScrollUp'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'scroll_to_end', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'scroll_by_element_index', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'element_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserScrollUp().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserScrollUp().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserScrollUp().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserScrollUp, a, b); + } +}; +var CortexStepBrowserScrollDown = class _CortexStepBrowserScrollDown extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * @generated from field: bool scroll_to_end = 2; + */ + scrollToEnd = false; + /** + * Optional flags for scrolling inside specific elements + * + * if true, scroll to the specific element + * + * @generated from field: bool scroll_by_element_index = 3; + */ + scrollByElementIndex = false; + /** + * Index of the element to scroll to + * + * @generated from field: int32 element_index = 4; + */ + elementIndex = 0; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 5; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserScrollDown'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'scroll_to_end', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 3, + name: 'scroll_by_element_index', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'element_index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserScrollDown().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserScrollDown().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserScrollDown().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserScrollDown, a, b); + } +}; +var CortexStepBrowserClickElement = class _CortexStepBrowserClickElement extends Message { + /** + * Inputs + * The page_id to click on. + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * The index of the DOM element to click on. Page must be injected to have + * elements indexed. + * + * @generated from field: int32 index = 2; + */ + index = 0; + /** + * Optional natural language description of the element to click on. + * + * @generated from field: string description = 3; + */ + description = ''; + /** + * Optional click type (left, right, double). Defaults to left click if not + * specified. + * + * @generated from field: exa.browser_pb.ClickType click_type = 5; + */ + clickType = ClickType.UNSPECIFIED; + /** + * Outputs + * + * @generated from field: bool user_rejected = 4; + */ + userRejected = false; + /** + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 6; + */ + pageMetadata; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 7; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserClickElement'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'index', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'click_type', + kind: 'enum', + T: proto3.getEnumType(ClickType), + }, + { + no: 4, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 6, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 7, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserClickElement().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserClickElement().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserClickElement().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserClickElement, a, b); + } +}; +var CortexStepBrowserListNetworkRequests = class _CortexStepBrowserListNetworkRequests extends Message { + /** + * Inputs + * The page_id to list network requests for. + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * Optional. Set to true to return the preserved requests over the last three + * navigations. + * + * @generated from field: bool include_preserved_requests = 2; + */ + includePreservedRequests = false; + /** + * Optional. The resource types to list network requests for. When empty, all + * resource types are listed. + * + * @generated from field: repeated string resource_types = 3; + */ + resourceTypes = []; + /** + * Outputs + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 4; + */ + pageMetadata; + /** + * String representation of the network requests for this action. + * + * @generated from field: string network_requests = 5; + */ + networkRequests = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserListNetworkRequests'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'include_preserved_requests', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 3, name: 'resource_types', kind: 'scalar', T: 9, repeated: true }, + { no: 4, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 5, + name: 'network_requests', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserListNetworkRequests().fromBinary( + bytes, + options, + ); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserListNetworkRequests().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserListNetworkRequests().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserListNetworkRequests, a, b); + } +}; +var CortexStepBrowserGetNetworkRequest = class _CortexStepBrowserGetNetworkRequest extends Message { + /** + * Inputs + * The page_id to get network request from. + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * The request ID to retrieve details for. + * + * @generated from field: string request_id = 2; + */ + requestId = ''; + /** + * Outputs + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 3; + */ + pageMetadata; + /** + * String representation of the network request details. + * + * @generated from field: string network_request_details = 4; + */ + networkRequestDetails = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserGetNetworkRequest'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'request_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 4, + name: 'network_request_details', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserGetNetworkRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserGetNetworkRequest().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserGetNetworkRequest().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserGetNetworkRequest, a, b); + } +}; +var ModelAliasResolutionPayload = class _ModelAliasResolutionPayload extends Message { + /** + * The model enum that the alias resolves to. + * + * @generated from field: exa.codeium_common_pb.Model model = 1; + */ + model = Model.UNSPECIFIED; + /** + * Model info override to be merged on top of default model info for the model + * enum. Only meant to be used with BYOM enum for custom models. + * + * @generated from field: exa.codeium_common_pb.ModelInfo model_info_override = 2; + */ + modelInfoOverride; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ModelAliasResolutionPayload'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'model', kind: 'enum', T: proto3.getEnumType(Model) }, + { no: 2, name: 'model_info_override', kind: 'message', T: ModelInfo }, + ]); + static fromBinary(bytes, options) { + return new _ModelAliasResolutionPayload().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ModelAliasResolutionPayload().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ModelAliasResolutionPayload().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_ModelAliasResolutionPayload, a, b); + } +}; +var CortexStepBrowserMouseWheel = class _CortexStepBrowserMouseWheel extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * @generated from field: int32 x = 2; + */ + x = 0; + /** + * @generated from field: int32 y = 3; + */ + y = 0; + /** + * @generated from field: int32 dx = 4; + */ + dx = 0; + /** + * @generated from field: int32 dy = 5; + */ + dy = 0; + /** + * Outputs + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 6; + */ + pageMetadata; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 7; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserMouseWheel'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'x', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'y', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'dx', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'dy', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { no: 6, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 7, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserMouseWheel().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserMouseWheel().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserMouseWheel().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserMouseWheel, a, b); + } +}; +var CortexStepBrowserMouseUp = class _CortexStepBrowserMouseUp extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * @generated from field: string button = 2; + */ + button = ''; + /** + * Outputs + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 3; + */ + pageMetadata; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 4; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserMouseUp'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'button', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 4, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserMouseUp().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserMouseUp().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserMouseUp().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserMouseUp, a, b); + } +}; +var CortexStepBrowserMouseDown = class _CortexStepBrowserMouseDown extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * @generated from field: string button = 2; + */ + button = ''; + /** + * Outputs + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 3; + */ + pageMetadata; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 4; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserMouseDown'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'button', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 4, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserMouseDown().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserMouseDown().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserMouseDown().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserMouseDown, a, b); + } +}; +var CortexStepBrowserRefreshPage = class _CortexStepBrowserRefreshPage extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * Outputs + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 2; + */ + pageMetadata; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 3; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserRefreshPage'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 3, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserRefreshPage().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserRefreshPage().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserRefreshPage().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserRefreshPage, a, b); + } +}; +var CortexStepBrowserPressKey = class _CortexStepBrowserPressKey extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * Note: Only one of key / text should be set in a well-formed tool call. + * Key name or combination, primarily for shortcuts and special keys (e.g., + * "Enter", "Control+C", "F1"). + * + * @generated from field: string key = 2; + */ + key = ''; + /** + * Text to type character by character. For regular text input. Cannot include + * special keys (e.g. "F1", "Enter"). + * + * @generated from field: string text = 3; + */ + text = ''; + /** + * Outputs + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 5; + */ + pageMetadata; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 4; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserPressKey'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'key', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'text', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 4, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserPressKey().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserPressKey().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserPressKey().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserPressKey, a, b); + } +}; +var CortexStepGenerateImage = class _CortexStepGenerateImage extends Message { + /** + * Inputs + * The text prompt to generate an image for. + * + * @generated from field: string prompt = 1; + */ + prompt = ''; + /** + * Optional absolute paths to the images to use in generation. Maximum of 3 + * images. + * + * @generated from field: repeated string image_paths = 2; + */ + imagePaths = []; + /** + * Name of the generated image file (without extension) when saving as + * artifact. + * + * @generated from field: string image_name = 4; + */ + imageName = ''; + /** + * Outputs + * The generated image. This is also saved in the artifacts directory with the + * path set in the ImageData. + * + * @generated from field: exa.codeium_common_pb.ImageData generated_image = 3 [deprecated = true]; + * @deprecated + */ + generatedImage; + /** + * The image generation model's name. + * + * @generated from field: string model_name = 5; + */ + modelName = ''; + /** + * @generated from field: exa.codeium_common_pb.Media generated_media = 6; + */ + generatedMedia; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepGenerateImage'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'image_paths', kind: 'scalar', T: 9, repeated: true }, + { + no: 4, + name: 'image_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 3, name: 'generated_image', kind: 'message', T: ImageData }, + { + no: 5, + name: 'model_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 6, name: 'generated_media', kind: 'message', T: Media }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepGenerateImage().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepGenerateImage().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepGenerateImage().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepGenerateImage, a, b); + } +}; +var CortexStepBrowserResizeWindow = class _CortexStepBrowserResizeWindow extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * New width for the browser window in display-independent pixels. + * Only used when window_state is 'normal'. + * + * @generated from field: int32 width = 2; + */ + width = 0; + /** + * New height for the browser window in display-independent pixels. + * Only used when window_state is 'normal'. + * + * @generated from field: int32 height = 3; + */ + height = 0; + /** + * Window state to set. ex. minimized, normal, etc. + * + * @generated from field: exa.browser_pb.WindowState window_state = 6; + */ + windowState = WindowState.UNSPECIFIED; + /** + * Whether the user rejected to resize the window (if the auto run decision + * was not to auto run). + * + * @generated from field: bool user_rejected = 4; + */ + userRejected = false; + /** + * Auto-populated metadata associated with the Browser page. + * + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 5; + */ + pageMetadata; + /** + * String representation of the browser state diff for this action. + * + * @generated from field: string browser_state_diff = 7; + */ + browserStateDiff = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserResizeWindow'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'width', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'height', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'window_state', + kind: 'enum', + T: proto3.getEnumType(WindowState), + }, + { + no: 4, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 5, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 7, + name: 'browser_state_diff', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserResizeWindow().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserResizeWindow().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserResizeWindow().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserResizeWindow, a, b); + } +}; +var CortexStepBrowserDragPixelToPixel = class _CortexStepBrowserDragPixelToPixel extends Message { + /** + * Inputs + * + * @generated from field: string page_id = 1; + */ + pageId = ''; + /** + * A waypoint may not necessarily be the start or end of the drag, such as if + * the agent starts a drag at point A, moves to point B, and then releases at + * point C. A, B, and C are all waypoints. + * There must be at least two waypoints in a well-formed tool call. + * + * @generated from field: repeated exa.codeium_common_pb.Point2 waypoints = 2; + */ + waypoints = []; + /** + * Outputs + * + * @generated from field: bool user_rejected = 6; + */ + userRejected = false; + /** + * @generated from field: exa.codeium_common_pb.BrowserPageMetadata page_metadata = 7; + */ + pageMetadata; + /** + * Screenshots showing the drag path. To avoid filling the context window with + * too many images, one screenshot might include multiple waypoints. We do + * ensure that each screen shows a contiguous set of waypoints, and that + * the screenshots are time-ordered. + * For example, if the tool call includes waypoints A, B, C, D, then it is + * possible for two screenshots to contain {A} and {B, C, D} respectively. + * It is also possible for there to be a single screenshot with {A, B, C, D}. + * + * @generated from field: repeated exa.codeium_common_pb.Media screenshots_with_drag_feedback = 8; + */ + screenshotsWithDragFeedback = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepBrowserDragPixelToPixel'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'page_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'waypoints', kind: 'message', T: Point2, repeated: true }, + { + no: 6, + name: 'user_rejected', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { no: 7, name: 'page_metadata', kind: 'message', T: BrowserPageMetadata }, + { + no: 8, + name: 'screenshots_with_drag_feedback', + kind: 'message', + T: Media, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepBrowserDragPixelToPixel().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepBrowserDragPixelToPixel().fromJson( + jsonValue, + options, + ); + } + static fromJsonString(jsonString, options) { + return new _CortexStepBrowserDragPixelToPixel().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepBrowserDragPixelToPixel, a, b); + } +}; +var CortexStepTaskBoundary = class _CortexStepTaskBoundary extends Message { + /** + * Inputs + * + * @generated from field: string task_name = 1; + */ + taskName = ''; + /** + * @generated from field: string task_status = 2; + */ + taskStatus = ''; + /** + * @generated from field: string task_summary = 3; + */ + taskSummary = ''; + /** + * @generated from field: string task_summary_with_citations = 4; + */ + taskSummaryWithCitations = ''; + /** + * @generated from field: string delta_summary = 6; + */ + deltaSummary = ''; + /** + * @generated from field: string delta_summary_with_citations = 7; + */ + deltaSummaryWithCitations = ''; + /** + * Outputs + * + * @generated from field: exa.cortex_pb.AgentMode mode = 5; + */ + mode = AgentMode.UNSPECIFIED; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepTaskBoundary'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'task_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'task_status', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'task_summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'task_summary_with_citations', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'delta_summary', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'delta_summary_with_citations', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 5, name: 'mode', kind: 'enum', T: proto3.getEnumType(AgentMode) }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepTaskBoundary().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepTaskBoundary().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepTaskBoundary().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepTaskBoundary, a, b); + } +}; +var CortexStepNotifyUser = class _CortexStepNotifyUser extends Message { + /** + * Inputs + * + * Files that request review + * + * @generated from field: repeated string review_absolute_uris = 1; + */ + reviewAbsoluteUris = []; + /** + * @generated from field: string notification_content = 2; + */ + notificationContent = ''; + /** + * @generated from field: bool is_blocking = 3; + */ + isBlocking = false; + /** + * Agent's confidence in the documents being reviewed (0.0-1.0) + * + * @generated from field: float confidence_score = 4 [deprecated = true]; + * @deprecated + */ + confidenceScore = 0; + /** + * Justification for the confidence score + * + * @generated from field: string confidence_justification = 5 [deprecated = true]; + * @deprecated + */ + confidenceJustification = ''; + /** + * Whether the agent believes it should auto-proceed without user interaction + * + * @generated from field: bool should_auto_proceed = 8; + */ + shouldAutoProceed = false; + /** + * Outputs + * URI of the generated diffs artifact + * + * @generated from field: string diffs_uri = 6; + */ + diffsUri = ''; + /** + * Whether the notify user step requires user interaction before the agent can + * proceed. Used to determine when to send auto-approved review steps. + * + * @generated from field: bool ask_for_user_feedback = 7; + */ + askForUserFeedback = false; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepNotifyUser'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'review_absolute_uris', + kind: 'scalar', + T: 9, + repeated: true, + }, + { + no: 2, + name: 'notification_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'is_blocking', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'confidence_score', + kind: 'scalar', + T: 2, + /* ScalarType.FLOAT */ + }, + { + no: 5, + name: 'confidence_justification', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 8, + name: 'should_auto_proceed', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 6, + name: 'diffs_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 7, + name: 'ask_for_user_feedback', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepNotifyUser().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepNotifyUser().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepNotifyUser().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepNotifyUser, a, b); + } +}; +var CodeAcknowledgementInfo = class _CodeAcknowledgementInfo extends Message { + /** + * The absolute URI of the file that the code acknowledgement is for. + * + * @generated from field: string uri_path = 1; + */ + uriPath = ''; + /** + * The code action steps that are relevant to the acknowledgement. + * + * @generated from field: repeated uint32 step_indices = 2; + */ + stepIndices = []; + /** + * The diff that happened as a result of the code acknowledgement. + * + * @generated from field: exa.diff_action_pb.UnifiedDiff diff = 3; + */ + diff; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CodeAcknowledgementInfo'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'uri_path', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'step_indices', kind: 'scalar', T: 13, repeated: true }, + { no: 3, name: 'diff', kind: 'message', T: UnifiedDiff }, + ]); + static fromBinary(bytes, options) { + return new _CodeAcknowledgementInfo().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CodeAcknowledgementInfo().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CodeAcknowledgementInfo().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CodeAcknowledgementInfo, a, b); + } +}; +var CortexStepCodeAcknowledgement = class _CortexStepCodeAcknowledgement extends Message { + /** + * Whether the user accepted the code action steps + * + * @generated from field: bool is_accept = 3; + */ + isAccept = false; + /** + * User-written feedback. + * + * @generated from field: string written_feedback = 4; + */ + writtenFeedback = ''; + /** + * How the user acknowledged the code action. + * + * @generated from field: exa.cortex_pb.CodeAcknowledgementScope acknowledgement_scope = 5; + */ + acknowledgementScope = CodeAcknowledgementScope.UNSPECIFIED; + /** + * code_acknowledgement_infos has length 1 if the + * acknowledgement_scope is FILE or HUNK, and >1 if the acknowledgement_scope + * is ALL. + * + * @generated from field: repeated exa.cortex_pb.CodeAcknowledgementInfo code_acknowledgement_infos = 7; + */ + codeAcknowledgementInfos = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepCodeAcknowledgement'; + static fields = proto3.util.newFieldList(() => [ + { + no: 3, + name: 'is_accept', + kind: 'scalar', + T: 8, + /* ScalarType.BOOL */ + }, + { + no: 4, + name: 'written_feedback', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'acknowledgement_scope', + kind: 'enum', + T: proto3.getEnumType(CodeAcknowledgementScope), + }, + { + no: 7, + name: 'code_acknowledgement_infos', + kind: 'message', + T: CodeAcknowledgementInfo, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepCodeAcknowledgement().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepCodeAcknowledgement().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepCodeAcknowledgement().fromJsonString( + jsonString, + options, + ); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepCodeAcknowledgement, a, b); + } +}; +var InternalSearchResults = class _InternalSearchResults extends Message { + /** + * @generated from field: string url = 1; + */ + url = ''; + /** + * @generated from field: string title = 2; + */ + title = ''; + /** + * @generated from field: string content = 3; + */ + content = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.InternalSearchResults'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'title', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _InternalSearchResults().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _InternalSearchResults().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _InternalSearchResults().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_InternalSearchResults, a, b); + } +}; +var CortexStepInternalSearch = class _CortexStepInternalSearch extends Message { + /** + * Inputs + * + * @generated from field: string query = 1; + */ + query = ''; + /** + * Outputs + * + * @generated from field: repeated exa.cortex_pb.InternalSearchResults results = 2; + */ + results = []; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepInternalSearch'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'query', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'results', + kind: 'message', + T: InternalSearchResults, + repeated: true, + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepInternalSearch().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepInternalSearch().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepInternalSearch().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepInternalSearch, a, b); + } +}; +var ArtifactReviewState = class _ArtifactReviewState extends Message { + /** + * @generated from field: string artifact_uri = 1; + */ + artifactUri = ''; + /** + * @generated from field: exa.cortex_pb.ArtifactReviewStatus status = 2; + */ + status = ArtifactReviewStatus.UNSPECIFIED; + /** + * @generated from field: google.protobuf.Timestamp last_reviewed_time = 3; + */ + lastReviewedTime; + /** + * @generated from field: string last_reviewed_content = 4; + */ + lastReviewedContent = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ArtifactReviewState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'artifact_uri', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(ArtifactReviewStatus), + }, + { no: 3, name: 'last_reviewed_time', kind: 'message', T: Timestamp }, + { + no: 4, + name: 'last_reviewed_content', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _ArtifactReviewState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ArtifactReviewState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ArtifactReviewState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ArtifactReviewState, a, b); + } +}; +var ConversationHistoryConfig = class _ConversationHistoryConfig extends Message { + /** + * @generated from field: optional bool enabled = 1; + */ + enabled; + /** + * @generated from field: int32 max_conversations = 2; + */ + maxConversations = 0; + /** + * @generated from field: int32 max_title_chars = 3; + */ + maxTitleChars = 0; + /** + * @generated from field: int32 max_user_intent_chars = 4; + */ + maxUserIntentChars = 0; + /** + * @generated from field: int32 max_conversation_logs_chars = 5; + */ + maxConversationLogsChars = 0; + /** + * @generated from field: int32 max_artifact_summary_chars = 6; + */ + maxArtifactSummaryChars = 0; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.ConversationHistoryConfig'; + static fields = proto3.util.newFieldList(() => [ + { no: 1, name: 'enabled', kind: 'scalar', T: 8, opt: true }, + { + no: 2, + name: 'max_conversations', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 3, + name: 'max_title_chars', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 4, + name: 'max_user_intent_chars', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 5, + name: 'max_conversation_logs_chars', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'max_artifact_summary_chars', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + ]); + static fromBinary(bytes, options) { + return new _ConversationHistoryConfig().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConversationHistoryConfig().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConversationHistoryConfig().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConversationHistoryConfig, a, b); + } +}; +var CortexStepSystemMessage = class _CortexStepSystemMessage extends Message { + /** + * @generated from field: string message = 1; + */ + message = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepSystemMessage'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'message', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepSystemMessage().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepSystemMessage().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepSystemMessage().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepSystemMessage, a, b); + } +}; +var CortexStepWait = class _CortexStepWait extends Message { + /** + * Duration to wait in milliseconds. + * + * @generated from field: int64 duration_ms = 1; + */ + durationMs = protoInt64.zero; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepWait'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'duration_ms', + kind: 'scalar', + T: 3, + /* ScalarType.INT64 */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepWait().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepWait().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepWait().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepWait, a, b); + } +}; +var CortexStepAgencyToolCall = class _CortexStepAgencyToolCall extends Message { + /** + * The target Agency agent name (e.g., "go_moma_agent") + * + * @generated from field: string agent_name = 1; + */ + agentName = ''; + /** + * The function being called (e.g., "moma_search") + * + * @generated from field: string function_name = 2; + */ + functionName = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepAgencyToolCall'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'agent_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'function_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepAgencyToolCall().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepAgencyToolCall().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepAgencyToolCall().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepAgencyToolCall, a, b); + } +}; +var CortexStepWorkspaceAPI = class _CortexStepWorkspaceAPI extends Message { + /** + * Full API URL (e.g., + * https://docs.googleapis.com/v1/documents/{documentId}:batchUpdate) + * + * @generated from field: string url = 1; + */ + url = ''; + /** + * HTTP method (GET, POST, PUT, DELETE). + * + * @generated from field: string http_method = 2; + */ + httpMethod = ''; + /** + * Request body JSON. + * + * @generated from field: string body = 3; + */ + body = ''; + /** + * User-facing explanation of what this call does. + * + * @generated from field: string description = 4; + */ + description = ''; + /** + * HTTP status code. + * + * @generated from field: int32 status_code = 5; + */ + statusCode = 0; + /** + * Raw JSON response. + * + * @generated from field: string response = 6; + */ + response = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepWorkspaceAPI'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'url', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'http_method', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'body', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'description', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 5, + name: 'status_code', + kind: 'scalar', + T: 5, + /* ScalarType.INT32 */ + }, + { + no: 6, + name: 'response', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepWorkspaceAPI().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepWorkspaceAPI().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepWorkspaceAPI().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepWorkspaceAPI, a, b); + } +}; +var GenericStepResult = class _GenericStepResult extends Message { + /** + * Result that will be shown to the model. + * + * @generated from field: string result = 1; + */ + result = ''; + /** + * Optional key-value metadata for additional context (e.g., for rendering). + * + * @generated from field: map metadata = 2; + */ + metadata = {}; + /** + * Optional step render info. + * + * @generated from field: exa.cortex_pb.StepRenderInfo step_render_info = 3; + */ + stepRenderInfo; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.GenericStepResult'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'result', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'metadata', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { no: 3, name: 'step_render_info', kind: 'message', T: StepRenderInfo }, + ]); + static fromBinary(bytes, options) { + return new _GenericStepResult().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _GenericStepResult().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _GenericStepResult().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_GenericStepResult, a, b); + } +}; +var CortexStepInvokeSubagent = class _CortexStepInvokeSubagent extends Message { + /** + * Name of the subagent to invoke. + * + * @generated from field: string subagent_name = 1; + */ + subagentName = ''; + /** + * Natural language prompt/instructions for the subagent. + * + * @generated from field: string prompt = 2; + */ + prompt = ''; + /** + * Result returned by the subagent (populated after execution). + * + * @generated from field: string result = 3; + */ + result = ''; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepInvokeSubagent'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'subagent_name', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'prompt', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 3, + name: 'result', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepInvokeSubagent().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepInvokeSubagent().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepInvokeSubagent().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepInvokeSubagent, a, b); + } +}; +var CortexStepGeneric = class _CortexStepGeneric extends Message { + /** + * Inputs + * + * @generated from field: map args = 1; + */ + args = {}; + /** + * Outputs + * + * @generated from field: exa.cortex_pb.GenericStepResult result = 2; + */ + result; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'exa.cortex_pb.CortexStepGeneric'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'args', + kind: 'map', + K: 9, + V: { + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + }, + { no: 2, name: 'result', kind: 'message', T: GenericStepResult }, + ]); + static fromBinary(bytes, options) { + return new _CortexStepGeneric().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _CortexStepGeneric().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _CortexStepGeneric().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_CortexStepGeneric, a, b); + } +}; + +// exa/proto_ts/dist/exa/gemini_coder/proto/trajectory_pb.js +var ExecutionStatus; +(function (ExecutionStatus2) { + ExecutionStatus2[(ExecutionStatus2['UNSPECIFIED'] = 0)] = 'UNSPECIFIED'; + ExecutionStatus2[(ExecutionStatus2['IDLE'] = 1)] = 'IDLE'; + ExecutionStatus2[(ExecutionStatus2['RUNNING'] = 2)] = 'RUNNING'; + ExecutionStatus2[(ExecutionStatus2['CANCELING'] = 3)] = 'CANCELING'; +})(ExecutionStatus || (ExecutionStatus = {})); +proto3.util.setEnumType(ExecutionStatus, 'gemini_coder.ExecutionStatus', [ + { no: 0, name: 'EXECUTION_STATUS_UNSPECIFIED' }, + { no: 1, name: 'EXECUTION_STATUS_IDLE' }, + { no: 2, name: 'EXECUTION_STATUS_RUNNING' }, + { no: 3, name: 'EXECUTION_STATUS_CANCELING' }, +]); +var Conversation2 = class _Conversation extends Message { + /** + * ID of the conversation. + * + * @generated from field: string conversation_id = 1; + */ + conversationId = ''; + /** + * The trajectory underlying the current conversation state. + * + * @generated from field: gemini_coder.Trajectory trajectory = 2; + */ + trajectory; + /** + * The current state of the conversation. + * + * @generated from field: gemini_coder.ConversationState state = 3; + */ + state; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'gemini_coder.Conversation'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'conversation_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { no: 2, name: 'trajectory', kind: 'message', T: Trajectory }, + { no: 3, name: 'state', kind: 'message', T: ConversationState }, + ]); + static fromBinary(bytes, options) { + return new _Conversation().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Conversation().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Conversation().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Conversation, a, b); + } +}; +var ConversationState = class _ConversationState extends Message { + /** + * ID of the underlying trajectory. + * + * @generated from field: string trajectory_id = 1; + */ + trajectoryId = ''; + /** + * The status of the execution. + * + * @generated from field: gemini_coder.ExecutionStatus status = 2; + */ + status = ExecutionStatus.UNSPECIFIED; + /** + * Steps staged to be included in the trajectory. These will be included in + * the next invocation. + * + * @generated from field: repeated gemini_coder.Step staged_steps = 3; + */ + stagedSteps = []; + /** + * The most recent execute request config. This needs to be stored in order to + * resume the trajectory in case of an agent crash. + * + * @generated from field: exa.cortex_pb.CascadeConfig execute_config = 4; + */ + executeConfig; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'gemini_coder.ConversationState'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'trajectory_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 2, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(ExecutionStatus), + }, + { no: 3, name: 'staged_steps', kind: 'message', T: Step, repeated: true }, + { no: 4, name: 'execute_config', kind: 'message', T: CascadeConfig }, + ]); + static fromBinary(bytes, options) { + return new _ConversationState().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _ConversationState().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _ConversationState().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_ConversationState, a, b); + } +}; +var Trajectory = class _Trajectory extends Message { + /** + * The ID of the trajectory. + * + * @generated from field: string trajectory_id = 1; + */ + trajectoryId = ''; + /** + * The ID of the conversation, which could be related + * + * @generated from field: string cascade_id = 6; + */ + cascadeId = ''; + /** + * to many trajectories. + * + * @generated from field: exa.cortex_pb.CortexTrajectoryType trajectory_type = 4; + */ + trajectoryType = CortexTrajectoryType.UNSPECIFIED; + /** + * @generated from field: repeated gemini_coder.Step steps = 2; + */ + steps = []; + /** + * See comment in CortexTrajectoryReference definition for full + * + * @generated from field: repeated exa.cortex_pb.CortexTrajectoryReference parent_references = 5; + */ + parentReferences = []; + /** + * explanation. + * + * @generated from field: repeated exa.cortex_pb.CortexStepGeneratorMetadata generator_metadata = 3; + */ + generatorMetadata = []; + /** + * Snapshots of executor metadata states at various points in the + * conversation, at a per-execution-loop cadence. + * + * @generated from field: repeated exa.cortex_pb.ExecutorMetadata executor_metadatas = 9; + */ + executorMetadatas = []; + /** + * @generated from field: exa.cortex_pb.CortexTrajectorySource source = 8; + */ + source = CortexTrajectorySource.UNSPECIFIED; + /** + * @generated from field: exa.cortex_pb.CortexTrajectoryMetadata metadata = 7; + */ + metadata; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'gemini_coder.Trajectory'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'trajectory_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 6, + name: 'cascade_id', + kind: 'scalar', + T: 9, + /* ScalarType.STRING */ + }, + { + no: 4, + name: 'trajectory_type', + kind: 'enum', + T: proto3.getEnumType(CortexTrajectoryType), + }, + { no: 2, name: 'steps', kind: 'message', T: Step, repeated: true }, + { + no: 5, + name: 'parent_references', + kind: 'message', + T: CortexTrajectoryReference, + repeated: true, + }, + { + no: 3, + name: 'generator_metadata', + kind: 'message', + T: CortexStepGeneratorMetadata, + repeated: true, + }, + { + no: 9, + name: 'executor_metadatas', + kind: 'message', + T: ExecutorMetadata, + repeated: true, + }, + { + no: 8, + name: 'source', + kind: 'enum', + T: proto3.getEnumType(CortexTrajectorySource), + }, + { no: 7, name: 'metadata', kind: 'message', T: CortexTrajectoryMetadata }, + ]); + static fromBinary(bytes, options) { + return new _Trajectory().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Trajectory().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Trajectory().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Trajectory, a, b); + } +}; +var Step = class _Step extends Message { + /** + * TODO(matthewli, nicholasjiang): Soon to be deprecated; the type should be + * inferred from the one-of payload. + * + * @generated from field: exa.cortex_pb.CortexStepType type = 1; + */ + type = CortexStepType.UNSPECIFIED; + /** + * @generated from field: exa.cortex_pb.CortexStepStatus status = 4; + */ + status = CortexStepStatus.UNSPECIFIED; + /** + * @generated from field: exa.cortex_pb.CortexStepMetadata metadata = 5; + */ + metadata; + /** + * Populated only if status is ERROR. + * + * @generated from field: exa.cortex_pb.CortexErrorDetails error = 31; + */ + error; + /** + * Permissions granted/denied during this step. + * + * @generated from field: exa.cortex_pb.TrajectoryPermissions permissions = 133; + */ + permissions; + /** + * @generated from oneof gemini_coder.Step.step + */ + step = { case: void 0 }; + /** + * DEPRECATED. + * TODO(jetski): Deprecated, reason: requested interaction should be built + * into the corresponding step payload. + * + * @generated from field: exa.cortex_pb.RequestedInteraction requested_interaction = 56 [deprecated = true]; + * @deprecated + */ + requestedInteraction; + /** + * TODO(tmitrovska): Deprecate, reason: unused. + * + * @generated from field: exa.cortex_pb.UserStepAnnotations user_annotations = 69 [deprecated = true]; + * @deprecated + */ + userAnnotations; + /** + * TODO(matthewli, nicholasjiang): Deprecate, reason: re-think how subagents + * work in the framework. + * + * @generated from field: gemini_coder.Trajectory subtrajectory = 6 [deprecated = true]; + * @deprecated + */ + subtrajectory; + constructor(data) { + super(); + proto3.util.initPartial(data, this); + } + static runtime = proto3; + static typeName = 'gemini_coder.Step'; + static fields = proto3.util.newFieldList(() => [ + { + no: 1, + name: 'type', + kind: 'enum', + T: proto3.getEnumType(CortexStepType), + }, + { + no: 4, + name: 'status', + kind: 'enum', + T: proto3.getEnumType(CortexStepStatus), + }, + { no: 5, name: 'metadata', kind: 'message', T: CortexStepMetadata }, + { no: 31, name: 'error', kind: 'message', T: CortexErrorDetails }, + { no: 133, name: 'permissions', kind: 'message', T: TrajectoryPermissions }, + { + no: 140, + name: 'generic', + kind: 'message', + T: CortexStepGeneric, + oneof: 'step', + }, + { + no: 12, + name: 'finish', + kind: 'message', + T: CortexStepFinish, + oneof: 'step', + }, + { + no: 9, + name: 'mquery', + kind: 'message', + T: CortexStepMquery, + oneof: 'step', + }, + { + no: 10, + name: 'code_action', + kind: 'message', + T: CortexStepCodeAction, + oneof: 'step', + }, + { + no: 11, + name: 'git_commit', + kind: 'message', + T: CortexStepGitCommit, + oneof: 'step', + }, + { + no: 13, + name: 'grep_search', + kind: 'message', + T: CortexStepGrepSearch, + oneof: 'step', + }, + { + no: 16, + name: 'compile', + kind: 'message', + T: CortexStepCompile, + oneof: 'step', + }, + { + no: 22, + name: 'view_code_item', + kind: 'message', + T: CortexStepViewCodeItem, + oneof: 'step', + }, + { + no: 24, + name: 'error_message', + kind: 'message', + T: CortexStepErrorMessage, + oneof: 'step', + }, + { + no: 28, + name: 'run_command', + kind: 'message', + T: CortexStepRunCommand, + oneof: 'step', + }, + { no: 34, name: 'find', kind: 'message', T: CortexStepFind, oneof: 'step' }, + { + no: 36, + name: 'suggested_responses', + kind: 'message', + T: CortexStepSuggestedResponses, + oneof: 'step', + }, + { + no: 37, + name: 'command_status', + kind: 'message', + T: CortexStepCommandStatus, + oneof: 'step', + }, + { + no: 40, + name: 'read_url_content', + kind: 'message', + T: CortexStepReadUrlContent, + oneof: 'step', + }, + { + no: 41, + name: 'view_content_chunk', + kind: 'message', + T: CortexStepViewContentChunk, + oneof: 'step', + }, + { + no: 42, + name: 'search_web', + kind: 'message', + T: CortexStepSearchWeb, + oneof: 'step', + }, + { + no: 47, + name: 'mcp_tool', + kind: 'message', + T: CortexStepMcpTool, + oneof: 'step', + }, + { + no: 55, + name: 'clipboard', + kind: 'message', + T: CortexStepClipboard, + oneof: 'step', + }, + { + no: 58, + name: 'view_file_outline', + kind: 'message', + T: CortexStepViewFileOutline, + oneof: 'step', + }, + { + no: 62, + name: 'list_resources', + kind: 'message', + T: CortexStepListResources, + oneof: 'step', + }, + { + no: 63, + name: 'read_resource', + kind: 'message', + T: CortexStepReadResource, + oneof: 'step', + }, + { + no: 64, + name: 'lint_diff', + kind: 'message', + T: CortexStepLintDiff, + oneof: 'step', + }, + { + no: 67, + name: 'open_browser_url', + kind: 'message', + T: CortexStepOpenBrowserUrl, + oneof: 'step', + }, + { + no: 72, + name: 'trajectory_search', + kind: 'message', + T: CortexStepTrajectorySearch, + oneof: 'step', + }, + { + no: 73, + name: 'execute_browser_javascript', + kind: 'message', + T: CortexStepExecuteBrowserJavaScript, + oneof: 'step', + }, + { + no: 74, + name: 'list_browser_pages', + kind: 'message', + T: CortexStepListBrowserPages, + oneof: 'step', + }, + { + no: 75, + name: 'capture_browser_screenshot', + kind: 'message', + T: CortexStepCaptureBrowserScreenshot, + oneof: 'step', + }, + { + no: 76, + name: 'click_browser_pixel', + kind: 'message', + T: CortexStepClickBrowserPixel, + oneof: 'step', + }, + { + no: 77, + name: 'read_terminal', + kind: 'message', + T: CortexStepReadTerminal, + oneof: 'step', + }, + { + no: 78, + name: 'capture_browser_console_logs', + kind: 'message', + T: CortexStepCaptureBrowserConsoleLogs, + oneof: 'step', + }, + { + no: 79, + name: 'read_browser_page', + kind: 'message', + T: CortexStepReadBrowserPage, + oneof: 'step', + }, + { + no: 80, + name: 'browser_get_dom', + kind: 'message', + T: CortexStepBrowserGetDom, + oneof: 'step', + }, + { + no: 85, + name: 'code_search', + kind: 'message', + T: CortexStepCodeSearch, + oneof: 'step', + }, + { + no: 86, + name: 'browser_input', + kind: 'message', + T: CortexStepBrowserInput, + oneof: 'step', + }, + { + no: 87, + name: 'browser_move_mouse', + kind: 'message', + T: CortexStepBrowserMoveMouse, + oneof: 'step', + }, + { + no: 88, + name: 'browser_select_option', + kind: 'message', + T: CortexStepBrowserSelectOption, + oneof: 'step', + }, + { + no: 89, + name: 'browser_scroll_up', + kind: 'message', + T: CortexStepBrowserScrollUp, + oneof: 'step', + }, + { + no: 90, + name: 'browser_scroll_down', + kind: 'message', + T: CortexStepBrowserScrollDown, + oneof: 'step', + }, + { + no: 91, + name: 'browser_click_element', + kind: 'message', + T: CortexStepBrowserClickElement, + oneof: 'step', + }, + { + no: 137, + name: 'browser_list_network_requests', + kind: 'message', + T: CortexStepBrowserListNetworkRequests, + oneof: 'step', + }, + { + no: 138, + name: 'browser_get_network_request', + kind: 'message', + T: CortexStepBrowserGetNetworkRequest, + oneof: 'step', + }, + { + no: 92, + name: 'browser_press_key', + kind: 'message', + T: CortexStepBrowserPressKey, + oneof: 'step', + }, + { + no: 93, + name: 'task_boundary', + kind: 'message', + T: CortexStepTaskBoundary, + oneof: 'step', + }, + { + no: 94, + name: 'notify_user', + kind: 'message', + T: CortexStepNotifyUser, + oneof: 'step', + }, + { + no: 95, + name: 'code_acknowledgement', + kind: 'message', + T: CortexStepCodeAcknowledgement, + oneof: 'step', + }, + { + no: 96, + name: 'internal_search', + kind: 'message', + T: CortexStepInternalSearch, + oneof: 'step', + }, + { + no: 97, + name: 'browser_subagent', + kind: 'message', + T: CortexStepBrowserSubagent, + oneof: 'step', + }, + { + no: 102, + name: 'knowledge_generation', + kind: 'message', + T: CortexStepKnowledgeGeneration, + oneof: 'step', + }, + { + no: 104, + name: 'generate_image', + kind: 'message', + T: CortexStepGenerateImage, + oneof: 'step', + }, + { + no: 101, + name: 'browser_scroll', + kind: 'message', + T: CortexStepBrowserScroll, + oneof: 'step', + }, + { + no: 109, + name: 'browser_resize_window', + kind: 'message', + T: CortexStepBrowserResizeWindow, + oneof: 'step', + }, + { + no: 110, + name: 'browser_drag_pixel_to_pixel', + kind: 'message', + T: CortexStepBrowserDragPixelToPixel, + oneof: 'step', + }, + { + no: 125, + name: 'browser_mouse_wheel', + kind: 'message', + T: CortexStepBrowserMouseWheel, + oneof: 'step', + }, + { + no: 134, + name: 'browser_mouse_up', + kind: 'message', + T: CortexStepBrowserMouseUp, + oneof: 'step', + }, + { + no: 135, + name: 'browser_mouse_down', + kind: 'message', + T: CortexStepBrowserMouseDown, + oneof: 'step', + }, + { + no: 139, + name: 'browser_refresh_page', + kind: 'message', + T: CortexStepBrowserRefreshPage, + oneof: 'step', + }, + { + no: 111, + name: 'conversation_history', + kind: 'message', + T: CortexStepConversationHistory, + oneof: 'step', + }, + { + no: 112, + name: 'knowledge_artifacts', + kind: 'message', + T: CortexStepKnowledgeArtifacts, + oneof: 'step', + }, + { + no: 113, + name: 'send_command_input', + kind: 'message', + T: CortexStepSendCommandInput, + oneof: 'step', + }, + { + no: 114, + name: 'system_message', + kind: 'message', + T: CortexStepSystemMessage, + oneof: 'step', + }, + { + no: 115, + name: 'wait', + kind: 'message', + T: CortexStepWait, + oneof: 'step', + }, + { + no: 129, + name: 'ki_insertion', + kind: 'message', + T: CortexStepKIInsertion, + oneof: 'step', + }, + { + no: 136, + name: 'workspace_api', + kind: 'message', + T: CortexStepWorkspaceAPI, + oneof: 'step', + }, + { + no: 143, + name: 'invoke_subagent', + kind: 'message', + T: CortexStepInvokeSubagent, + oneof: 'step', + }, + { + no: 106, + name: 'compile_applet', + kind: 'message', + T: CortexStepCompileApplet, + oneof: 'step', + }, + { + no: 107, + name: 'install_applet_dependencies', + kind: 'message', + T: CortexStepInstallAppletDependencies, + oneof: 'step', + }, + { + no: 108, + name: 'install_applet_package', + kind: 'message', + T: CortexStepInstallAppletPackage, + oneof: 'step', + }, + { + no: 121, + name: 'set_up_firebase', + kind: 'message', + T: CortexStepSetUpFirebase, + oneof: 'step', + }, + { + no: 123, + name: 'restart_dev_server', + kind: 'message', + T: CortexStepRestartDevServer, + oneof: 'step', + }, + { + no: 124, + name: 'deploy_firebase', + kind: 'message', + T: CortexStepDeployFirebase, + oneof: 'step', + }, + { + no: 126, + name: 'lint_applet', + kind: 'message', + T: CortexStepLintApplet, + oneof: 'step', + }, + { + no: 127, + name: 'shell_exec', + kind: 'message', + T: CortexStepShellExec, + oneof: 'step', + }, + { + no: 128, + name: 'define_new_env_variable', + kind: 'message', + T: CortexStepDefineNewEnvVariable, + oneof: 'step', + }, + { + no: 142, + name: 'write_blob', + kind: 'message', + T: CortexStepWriteBlob, + oneof: 'step', + }, + { + no: 116, + name: 'agency_tool_call', + kind: 'message', + T: CortexStepAgencyToolCall, + oneof: 'step', + }, + { + no: 19, + name: 'user_input', + kind: 'message', + T: CortexStepUserInput, + oneof: 'step', + }, + { + no: 20, + name: 'planner_response', + kind: 'message', + T: CortexStepPlannerResponse, + oneof: 'step', + }, + { + no: 14, + name: 'view_file', + kind: 'message', + T: CortexStepViewFile, + oneof: 'step', + }, + { + no: 15, + name: 'list_directory', + kind: 'message', + T: CortexStepListDirectory, + oneof: 'step', + }, + { + no: 105, + name: 'delete_directory', + kind: 'message', + T: CortexStepDeleteDirectory, + oneof: 'step', + }, + { + no: 30, + name: 'checkpoint', + kind: 'message', + T: CortexStepCheckpoint, + oneof: 'step', + }, + { + no: 98, + name: 'file_change', + kind: 'message', + T: CortexStepFileChange, + oneof: 'step', + }, + { + no: 100, + name: 'move', + kind: 'message', + T: CortexStepMove, + oneof: 'step', + }, + { + no: 103, + name: 'ephemeral_message', + kind: 'message', + T: CortexStepEphemeralMessage, + oneof: 'step', + }, + { + no: 7, + name: 'dummy', + kind: 'message', + T: CortexStepDummy, + oneof: 'step', + }, + { + no: 8, + name: 'plan_input', + kind: 'message', + T: CortexStepPlanInput, + oneof: 'step', + }, + { + no: 21, + name: 'file_breakdown', + kind: 'message', + T: CortexStepFileBreakdown, + oneof: 'step', + }, + { + no: 23, + name: 'write_to_file', + kind: 'message', + T: CortexStepWriteToFile, + oneof: 'step', + }, + { + no: 32, + name: 'propose_code', + kind: 'message', + T: CortexStepProposeCode, + oneof: 'step', + }, + { + no: 35, + name: 'search_knowledge_base', + kind: 'message', + T: CortexStepSearchKnowledgeBase, + oneof: 'step', + }, + { + no: 39, + name: 'lookup_knowledge_base', + kind: 'message', + T: CortexStepLookupKnowledgeBase, + oneof: 'step', + }, + { + no: 48, + name: 'manager_feedback', + kind: 'message', + T: CortexStepManagerFeedback, + oneof: 'step', + }, + { + no: 49, + name: 'tool_call_proposal', + kind: 'message', + T: CortexStepToolCallProposal, + oneof: 'step', + }, + { + no: 50, + name: 'tool_call_choice', + kind: 'message', + T: CortexStepToolCallChoice, + oneof: 'step', + }, + { + no: 52, + name: 'trajectory_choice', + kind: 'message', + T: CortexStepTrajectoryChoice, + oneof: 'step', + }, + { + no: 59, + name: 'check_deploy_status', + kind: 'message', + T: CortexStepCheckDeployStatus, + oneof: 'step', + }, + { + no: 60, + name: 'post_pr_review', + kind: 'message', + T: CortexStepPostPrReview, + oneof: 'step', + }, + { + no: 65, + name: 'find_all_references', + kind: 'message', + T: CortexStepFindAllReferences, + oneof: 'step', + }, + { + no: 66, + name: 'brain_update', + kind: 'message', + T: CortexStepBrainUpdate, + oneof: 'step', + }, + { + no: 68, + name: 'run_extension_code', + kind: 'message', + T: CortexStepRunExtensionCode, + oneof: 'step', + }, + { + no: 70, + name: 'add_annotation', + kind: 'message', + T: CortexStepAddAnnotation, + oneof: 'step', + }, + { + no: 71, + name: 'proposal_feedback', + kind: 'message', + T: CortexStepProposalFeedback, + oneof: 'step', + }, + { + no: 43, + name: 'retrieve_memory', + kind: 'message', + T: CortexStepRetrieveMemory, + oneof: 'step', + }, + { + no: 38, + name: 'memory', + kind: 'message', + T: CortexStepMemory, + oneof: 'step', + }, + { + no: 56, + name: 'requested_interaction', + kind: 'message', + T: RequestedInteraction, + }, + { + no: 69, + name: 'user_annotations', + kind: 'message', + T: UserStepAnnotations, + }, + { no: 6, name: 'subtrajectory', kind: 'message', T: Trajectory }, + ]); + static fromBinary(bytes, options) { + return new _Step().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new _Step().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new _Step().fromJsonString(jsonString, options); + } + static equals(a, b) { + return proto3.util.equals(_Step, a, b); + } +}; + +// trajectory_teleporter_tmp.ts +var DEFAULT_KEY = Buffer.from('safeCodeiumworldKeYsecretBalloon'); +var NONCE_SIZE = 12; +var TAG_SIZE = 16; +function decrypt(data, key = DEFAULT_KEY) { + if (data.length < NONCE_SIZE + TAG_SIZE) { + throw new Error('Data too short'); + } + const nonce = data.subarray(0, NONCE_SIZE); + const tag = data.subarray(data.length - TAG_SIZE); + const ciphertext = data.subarray(NONCE_SIZE, data.length - TAG_SIZE); + const decipher = crypto.createDecipheriv('aes-256-gcm', key, nonce); + decipher.setAuthTag(tag); + return Buffer.concat([decipher.update(ciphertext), decipher.final()]); +} +function encrypt(data, key = DEFAULT_KEY) { + const nonce = crypto.randomBytes(NONCE_SIZE); + const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce); + const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]); + const tag = cipher.getAuthTag(); + return Buffer.concat([nonce, ciphertext, tag]); +} +function trajectoryToJson(data) { + let pbData; + try { + pbData = decrypt(data); + } catch (_e) { + pbData = data; + } + const trajectory = Trajectory.fromBinary(pbData); + return trajectory.toJson(); +} +function jsonToTrajectory(json) { + const trajectory = Trajectory.fromJson(json, { ignoreUnknownFields: true }); + const pbData = Buffer.from(trajectory.toBinary()); + return encrypt(pbData); +} +export { decrypt, encrypt, jsonToTrajectory, trajectoryToJson }; +/** + * @license + * Copyright 2026 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ diff --git a/packages/core/src/teleportation/trajectory_teleporter.ts b/packages/core/src/teleportation/trajectory_teleporter.ts new file mode 100644 index 0000000000..abbdec1760 --- /dev/null +++ b/packages/core/src/teleportation/trajectory_teleporter.ts @@ -0,0 +1,79 @@ +/** + * @license + * Copyright 2026 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ +// eslint-disable-next-line @typescript-eslint/ban-ts-comment +// @ts-nocheck +import * as crypto from 'node:crypto'; +import { Trajectory } from './exa/proto_ts/dist/exa/gemini_coder/proto/trajectory_pb.js'; +/* eslint-disable @typescript-eslint/no-unsafe-assignment */ + +const DEFAULT_KEY = Buffer.from('safeCodeiumworldKeYsecretBalloon'); +const NONCE_SIZE = 12; // GCM default nonce size +const TAG_SIZE = 16; // GCM default tag size + +/** + * Decrypts data using AES-256-GCM. + * The data is expected to be in the format: [nonce (12b)][ciphertext][tag (16b)] + */ +export function decrypt(data: Buffer, key: Buffer = DEFAULT_KEY): Buffer { + if (data.length < NONCE_SIZE + TAG_SIZE) { + throw new Error('Data too short'); + } + + const nonce = data.subarray(0, NONCE_SIZE); + const tag = data.subarray(data.length - TAG_SIZE); + const ciphertext = data.subarray(NONCE_SIZE, data.length - TAG_SIZE); + + const decipher = crypto.createDecipheriv('aes-256-gcm', key, nonce); + decipher.setAuthTag(tag); + + return Buffer.concat([decipher.update(ciphertext), decipher.final()]); +} + +/** + * Encrypts data using AES-256-GCM. + * Returns data in the format: [nonce (12b)][ciphertext][tag (16b)] + */ +export function encrypt(data: Buffer, key: Buffer = DEFAULT_KEY): Buffer { + const nonce = crypto.randomBytes(NONCE_SIZE); + const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce); + + const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]); + const tag = cipher.getAuthTag(); + + return Buffer.concat([nonce, ciphertext, tag]); +} + +/** + * Converts Antigravity binary trajectory to JSON. + */ +export function trajectoryToJson( + data: Buffer, + key: Buffer = DEFAULT_KEY, +): unknown { + let pbData: Buffer; + try { + // Try to decrypt first + pbData = decrypt(data, key); + } catch (_e) { + // Fallback to plain protobuf if decryption fails + pbData = data; + } + + const trajectory = Trajectory.fromBinary(pbData); + return trajectory.toJson(); +} + +/** + * Converts JSON to Antigravity binary trajectory (encrypted). + */ +export function jsonToTrajectory( + json: unknown, + key: Buffer = DEFAULT_KEY, +): Buffer { + const trajectory = Trajectory.fromJson(json, { ignoreUnknownFields: true }); + const pbData = Buffer.from(trajectory.toBinary()); + return encrypt(pbData, key); +}