repoburg 1.0.68 → 1.1.0

package/backend/dist/packages/gemini-core/src/code_assist/setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.js","sourceRoot":"","sources":["../../../../../packages/gemini-core/src/code_assist/setup.ts"],"names":[],"mappings":"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"}

package/backend/dist/packages/gemini-core/src/code_assist/types.d.ts

@@ -0,0 +1,106 @@
+export interface ClientMetadata {
+    ideType?: ClientMetadataIdeType;
+    ideVersion?: string;
+    pluginVersion?: string;
+    platform?: ClientMetadataPlatform;
+    updateChannel?: string;
+    duetProject?: string;
+    pluginType?: ClientMetadataPluginType;
+    ideName?: string;
+}
+export type ClientMetadataIdeType = 'IDE_UNSPECIFIED' | 'VSCODE' | 'INTELLIJ' | 'VSCODE_CLOUD_WORKSTATION' | 'INTELLIJ_CLOUD_WORKSTATION' | 'CLOUD_SHELL';
+export type ClientMetadataPlatform = 'PLATFORM_UNSPECIFIED' | 'DARWIN_AMD64' | 'DARWIN_ARM64' | 'LINUX_AMD64' | 'LINUX_ARM64' | 'WINDOWS_AMD64';
+export type ClientMetadataPluginType = 'PLUGIN_UNSPECIFIED' | 'CLOUD_CODE' | 'GEMINI' | 'AIPLUGIN_INTELLIJ' | 'AIPLUGIN_STUDIO';
+export interface LoadCodeAssistRequest {
+    cloudaicompanionProject?: string;
+    metadata: ClientMetadata;
+}
+export interface LoadCodeAssistResponse {
+    currentTier?: GeminiUserTier | null;
+    allowedTiers?: GeminiUserTier[] | null;
+    ineligibleTiers?: IneligibleTier[] | null;
+    cloudaicompanionProject?: string | null;
+}
+export interface GeminiUserTier {
+    id: UserTierId;
+    name?: string;
+    description?: string;
+    userDefinedCloudaicompanionProject?: boolean | null;
+    isDefault?: boolean;
+    privacyNotice?: PrivacyNotice;
+    hasAcceptedTos?: boolean;
+    hasOnboardedPreviously?: boolean;
+}
+export interface IneligibleTier {
+    reasonCode: IneligibleTierReasonCode;
+    reasonMessage: string;
+    tierId: UserTierId;
+    tierName: string;
+}
+export declare enum IneligibleTierReasonCode {
+    DASHER_USER = "DASHER_USER",
+    INELIGIBLE_ACCOUNT = "INELIGIBLE_ACCOUNT",
+    NON_USER_ACCOUNT = "NON_USER_ACCOUNT",
+    RESTRICTED_AGE = "RESTRICTED_AGE",
+    RESTRICTED_NETWORK = "RESTRICTED_NETWORK",
+    UNKNOWN = "UNKNOWN",
+    UNKNOWN_LOCATION = "UNKNOWN_LOCATION",
+    UNSUPPORTED_LOCATION = "UNSUPPORTED_LOCATION"
+}
+export declare enum UserTierId {
+    FREE = "free-tier",
+    LEGACY = "legacy-tier",
+    STANDARD = "standard-tier"
+}
+export interface PrivacyNotice {
+    showNotice: boolean;
+    noticeText?: string;
+}
+export interface OnboardUserRequest {
+    tierId: string | undefined;
+    cloudaicompanionProject: string | undefined;
+    metadata: ClientMetadata | undefined;
+}
+export interface LongRunningOperationResponse {
+    name: string;
+    done?: boolean;
+    response?: OnboardUserResponse;
+}
+export interface OnboardUserResponse {
+    cloudaicompanionProject?: {
+        id: string;
+        name: string;
+    };
+}
+export declare enum OnboardUserStatusCode {
+    Default = "DEFAULT",
+    Notice = "NOTICE",
+    Warning = "WARNING",
+    Error = "ERROR"
+}
+export interface OnboardUserStatus {
+    statusCode: OnboardUserStatusCode;
+    displayMessage: string;
+    helpLink: HelpLinkUrl | undefined;
+}
+export interface HelpLinkUrl {
+    description: string;
+    url: string;
+}
+export interface SetCodeAssistGlobalUserSettingRequest {
+    cloudaicompanionProject?: string;
+    freeTierDataCollectionOptin: boolean;
+}
+export interface CodeAssistGlobalUserSettingResponse {
+    cloudaicompanionProject?: string;
+    freeTierDataCollectionOptin: boolean;
+}
+export interface GoogleRpcResponse {
+    error?: {
+        details?: GoogleRpcErrorInfo[];
+    };
+}
+interface GoogleRpcErrorInfo {
+    reason?: string;
+}
+export {};

package/backend/dist/packages/gemini-core/src/code_assist/types.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnboardUserStatusCode = exports.UserTierId = exports.IneligibleTierReasonCode = void 0;
+var IneligibleTierReasonCode;
+(function (IneligibleTierReasonCode) {
+    IneligibleTierReasonCode["DASHER_USER"] = "DASHER_USER";
+    IneligibleTierReasonCode["INELIGIBLE_ACCOUNT"] = "INELIGIBLE_ACCOUNT";
+    IneligibleTierReasonCode["NON_USER_ACCOUNT"] = "NON_USER_ACCOUNT";
+    IneligibleTierReasonCode["RESTRICTED_AGE"] = "RESTRICTED_AGE";
+    IneligibleTierReasonCode["RESTRICTED_NETWORK"] = "RESTRICTED_NETWORK";
+    IneligibleTierReasonCode["UNKNOWN"] = "UNKNOWN";
+    IneligibleTierReasonCode["UNKNOWN_LOCATION"] = "UNKNOWN_LOCATION";
+    IneligibleTierReasonCode["UNSUPPORTED_LOCATION"] = "UNSUPPORTED_LOCATION";
+})(IneligibleTierReasonCode || (exports.IneligibleTierReasonCode = IneligibleTierReasonCode = {}));
+var UserTierId;
+(function (UserTierId) {
+    UserTierId["FREE"] = "free-tier";
+    UserTierId["LEGACY"] = "legacy-tier";
+    UserTierId["STANDARD"] = "standard-tier";
+})(UserTierId || (exports.UserTierId = UserTierId = {}));
+var OnboardUserStatusCode;
+(function (OnboardUserStatusCode) {
+    OnboardUserStatusCode["Default"] = "DEFAULT";
+    OnboardUserStatusCode["Notice"] = "NOTICE";
+    OnboardUserStatusCode["Warning"] = "WARNING";
+    OnboardUserStatusCode["Error"] = "ERROR";
+})(OnboardUserStatusCode || (exports.OnboardUserStatusCode = OnboardUserStatusCode = {}));
+//# sourceMappingURL=types.js.map

package/backend/dist/packages/gemini-core/src/code_assist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../packages/gemini-core/src/code_assist/types.ts"],"names":[],"mappings":";;;AAuFA,IAAY,wBAWX;AAXD,WAAY,wBAAwB;IAElC,uDAA2B,CAAA;IAC3B,qEAAyC,CAAA;IACzC,iEAAqC,CAAA;IACrC,6DAAiC,CAAA;IACjC,qEAAyC,CAAA;IACzC,+CAAmB,CAAA;IACnB,iEAAqC,CAAA;IACrC,yEAA6C,CAAA;AAE/C,CAAC,EAXW,wBAAwB,wCAAxB,wBAAwB,QAWnC;AAMD,IAAY,UAIX;AAJD,WAAY,UAAU;IACpB,gCAAkB,CAAA;IAClB,oCAAsB,CAAA;IACtB,wCAA0B,CAAA;AAC5B,CAAC,EAJW,UAAU,0BAAV,UAAU,QAIrB;AA+CD,IAAY,qBAKX;AALD,WAAY,qBAAqB;IAC/B,4CAAmB,CAAA;IACnB,0CAAiB,CAAA;IACjB,4CAAmB,CAAA;IACnB,wCAAe,CAAA;AACjB,CAAC,EALW,qBAAqB,qCAArB,qBAAqB,QAKhC"}

package/backend/dist/packages/gemini-core/src/config/config.d.ts

@@ -0,0 +1,22 @@
+import type { ContentGenerator, ContentGeneratorConfig } from '../core/contentGenerator';
+import { AuthType } from '../core/contentGenerator';
+import { DEFAULT_GEMINI_FLASH_MODEL } from './models';
+export interface ConfigParameters {
+    sessionId: string;
+    model: string;
+}
+export declare class Config {
+    private contentGeneratorConfig;
+    private contentGenerator;
+    private readonly sessionId;
+    private model;
+    constructor(params: ConfigParameters);
+    getContentGenerator(): ContentGenerator;
+    refreshAuth(authMethod: AuthType): Promise<void>;
+    getSessionId(): string;
+    getModel(): string;
+    setModel(newModel: string): void;
+    isBrowserLaunchSuppressed(): boolean;
+    getContentGeneratorConfig(): ContentGeneratorConfig;
+}
+export { DEFAULT_GEMINI_FLASH_MODEL };

package/backend/dist/packages/gemini-core/src/config/config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GEMINI_FLASH_MODEL = exports.Config = void 0;
+const node_process_1 = require("node:process");
+const contentGenerator_1 = require("../core/contentGenerator");
+const models_1 = require("./models");
+Object.defineProperty(exports, "DEFAULT_GEMINI_FLASH_MODEL", { enumerable: true, get: function () { return models_1.DEFAULT_GEMINI_FLASH_MODEL; } });
+class Config {
+    constructor(params) {
+        this.sessionId = params.sessionId;
+        this.model = params.model;
+    }
+    getContentGenerator() {
+        return this.contentGenerator;
+    }
+    async refreshAuth(authMethod) {
+        const newContentGeneratorConfig = (0, contentGenerator_1.createContentGeneratorConfig)(this, authMethod);
+        this.contentGenerator = await (0, contentGenerator_1.createContentGenerator)(newContentGeneratorConfig, this, this.getSessionId());
+        this.contentGeneratorConfig = newContentGeneratorConfig;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getModel() {
+        return this.model;
+    }
+    setModel(newModel) {
+        this.model = newModel;
+    }
+    isBrowserLaunchSuppressed() {
+        return node_process_1.default.env['NO_BROWSER'] === 'true';
+    }
+    getContentGeneratorConfig() {
+        return this.contentGeneratorConfig;
+    }
+}
+exports.Config = Config;
+//# sourceMappingURL=config.js.map

package/backend/dist/packages/gemini-core/src/config/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../../../packages/gemini-core/src/config/config.ts"],"names":[],"mappings":";;;AAMA,+CAAmC;AAKnC,+DAIkC;AAClC,qCAAsD;AA0D7C,2GA1DA,mCAA0B,OA0DA;AAnDnC,MAAa,MAAM;IAMjB,YAAY,MAAwB;QAClC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC5B,CAAC;IAED,mBAAmB;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,UAAoB;QACpC,MAAM,yBAAyB,GAAG,IAAA,+CAA4B,EAC5D,IAAI,EACJ,UAAU,CACX,CAAC;QACF,IAAI,CAAC,gBAAgB,GAAG,MAAM,IAAA,yCAAsB,EAClD,yBAAyB,EACzB,IAAI,EACJ,IAAI,CAAC,YAAY,EAAE,CACpB,CAAC;QAEF,IAAI,CAAC,sBAAsB,GAAG,yBAAyB,CAAC;IAC1D,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,QAAQ,CAAC,QAAgB;QACvB,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC;IACxB,CAAC;IAGD,yBAAyB;QACvB,OAAO,sBAAO,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,MAAM,CAAC;IAC9C,CAAC;IAED,yBAAyB;QACvB,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACrC,CAAC;CACF;AAjDD,wBAiDC"}

package/backend/dist/packages/gemini-core/src/config/models.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_GEMINI_MODEL = "gemini-2.5-pro";
+export declare const DEFAULT_GEMINI_FLASH_MODEL = "gemini-2.5-flash";
+export declare const DEFAULT_GEMINI_FLASH_LITE_MODEL = "gemini-2.5-flash-lite";
+export declare const DEFAULT_GEMINI_MODEL_AUTO = "auto";
+export declare const DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
+export declare function getEffectiveModel(requestedModel: string): string;

package/backend/dist/packages/gemini-core/src/config/models.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GEMINI_EMBEDDING_MODEL = exports.DEFAULT_GEMINI_MODEL_AUTO = exports.DEFAULT_GEMINI_FLASH_LITE_MODEL = exports.DEFAULT_GEMINI_FLASH_MODEL = exports.DEFAULT_GEMINI_MODEL = void 0;
+exports.getEffectiveModel = getEffectiveModel;
+exports.DEFAULT_GEMINI_MODEL = 'gemini-2.5-pro';
+exports.DEFAULT_GEMINI_FLASH_MODEL = 'gemini-2.5-flash';
+exports.DEFAULT_GEMINI_FLASH_LITE_MODEL = 'gemini-2.5-flash-lite';
+exports.DEFAULT_GEMINI_MODEL_AUTO = 'auto';
+exports.DEFAULT_GEMINI_EMBEDDING_MODEL = 'gemini-embedding-001';
+function getEffectiveModel(requestedModel) {
+    return requestedModel;
+}
+//# sourceMappingURL=models.js.map

package/backend/dist/packages/gemini-core/src/config/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../../packages/gemini-core/src/config/models.ts"],"names":[],"mappings":";;;AAoBA,8CAEC;AAhBY,QAAA,oBAAoB,GAAG,gBAAgB,CAAC;AACxC,QAAA,0BAA0B,GAAG,kBAAkB,CAAC;AAChD,QAAA,+BAA+B,GAAG,uBAAuB,CAAC;AAE1D,QAAA,yBAAyB,GAAG,MAAM,CAAC;AAEnC,QAAA,8BAA8B,GAAG,sBAAsB,CAAC;AAQrE,SAAgB,iBAAiB,CAAC,cAAsB;IACtD,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/backend/dist/packages/gemini-core/src/config/storage.d.ts

@@ -0,0 +1,8 @@
+export declare const GEMINI_DIR = ".gemini";
+export declare const GOOGLE_ACCOUNTS_FILENAME = "google_accounts.json";
+export declare const OAUTH_FILE = "oauth_creds.json";
+export declare class Storage {
+    static getGlobalGeminiDir(): string;
+    static getGoogleAccountsPath(): string;
+    static getOAuthCredsPath(): string;
+}

package/backend/dist/packages/gemini-core/src/config/storage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = exports.OAUTH_FILE = exports.GOOGLE_ACCOUNTS_FILENAME = exports.GEMINI_DIR = void 0;
+const path = require("node:path");
+const os = require("node:os");
+exports.GEMINI_DIR = '.gemini';
+exports.GOOGLE_ACCOUNTS_FILENAME = 'google_accounts.json';
+exports.OAUTH_FILE = 'oauth_creds.json';
+class Storage {
+    static getGlobalGeminiDir() {
+        const homeDir = os.homedir();
+        if (!homeDir) {
+            return path.join(os.tmpdir(), '.gemini');
+        }
+        return path.join(homeDir, exports.GEMINI_DIR);
+    }
+    static getGoogleAccountsPath() {
+        return path.join(Storage.getGlobalGeminiDir(), exports.GOOGLE_ACCOUNTS_FILENAME);
+    }
+    static getOAuthCredsPath() {
+        return path.join(Storage.getGlobalGeminiDir(), exports.OAUTH_FILE);
+    }
+}
+exports.Storage = Storage;
+//# sourceMappingURL=storage.js.map

package/backend/dist/packages/gemini-core/src/config/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../../../../packages/gemini-core/src/config/storage.ts"],"names":[],"mappings":";;;AAMA,kCAAkC;AAClC,8BAA8B;AAEjB,QAAA,UAAU,GAAG,SAAS,CAAC;AACvB,QAAA,wBAAwB,GAAG,sBAAsB,CAAC;AAClD,QAAA,UAAU,GAAG,kBAAkB,CAAC;AAE7C,MAAa,OAAO;IAClB,MAAM,CAAC,kBAAkB;QACvB,MAAM,OAAO,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC;QAC7B,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,SAAS,CAAC,CAAC;QAC3C,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,kBAAU,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,CAAC,qBAAqB;QAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,EAAE,gCAAwB,CAAC,CAAC;IAC3E,CAAC;IAED,MAAM,CAAC,iBAAiB;QACtB,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,EAAE,kBAAU,CAAC,CAAC;IAC7D,CAAC;CACF;AAhBD,0BAgBC"}

package/backend/dist/packages/gemini-core/src/core/contentGenerator.d.ts

@@ -0,0 +1,23 @@
+import type { CountTokensResponse, GenerateContentResponse, GenerateContentParameters, CountTokensParameters, EmbedContentResponse, EmbedContentParameters } from '@google/genai';
+import type { Config } from '../config/config';
+import type { UserTierId } from '../code_assist/types';
+export interface ContentGenerator {
+    generateContent(request: GenerateContentParameters, userPromptId: string): Promise<GenerateContentResponse>;
+    generateContentStream(request: GenerateContentParameters, userPromptId: string): Promise<AsyncGenerator<GenerateContentResponse>>;
+    countTokens(request: CountTokensParameters): Promise<CountTokensResponse>;
+    embedContent(request: EmbedContentParameters): Promise<EmbedContentResponse>;
+    userTier?: UserTierId;
+}
+export declare enum AuthType {
+    LOGIN_WITH_GOOGLE = "oauth-personal",
+    USE_GEMINI = "gemini-api-key",
+    USE_VERTEX_AI = "vertex-ai",
+    CLOUD_SHELL = "cloud-shell"
+}
+export type ContentGeneratorConfig = {
+    apiKey?: string;
+    vertexai?: boolean;
+    authType?: AuthType;
+};
+export declare function createContentGeneratorConfig(config: Config, authType: AuthType | undefined): ContentGeneratorConfig;
+export declare function createContentGenerator(config: ContentGeneratorConfig, gcConfig: Config, sessionId?: string): Promise<ContentGenerator>;

package/backend/dist/packages/gemini-core/src/core/contentGenerator.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthType = void 0;
+exports.createContentGeneratorConfig = createContentGeneratorConfig;
+exports.createContentGenerator = createContentGenerator;
+const genai_1 = require("@google/genai");
+const codeAssist_1 = require("../code_assist/codeAssist");
+var AuthType;
+(function (AuthType) {
+    AuthType["LOGIN_WITH_GOOGLE"] = "oauth-personal";
+    AuthType["USE_GEMINI"] = "gemini-api-key";
+    AuthType["USE_VERTEX_AI"] = "vertex-ai";
+    AuthType["CLOUD_SHELL"] = "cloud-shell";
+})(AuthType || (exports.AuthType = AuthType = {}));
+function createContentGeneratorConfig(config, authType) {
+    const geminiApiKey = process.env['GEMINI_API_KEY'] || undefined;
+    const googleApiKey = process.env['GOOGLE_API_KEY'] || undefined;
+    const googleCloudProject = process.env['GOOGLE_CLOUD_PROJECT'] || undefined;
+    const googleCloudLocation = process.env['GOOGLE_CLOUD_LOCATION'] || undefined;
+    const contentGeneratorConfig = {
+        authType,
+    };
+    if (authType === AuthType.LOGIN_WITH_GOOGLE ||
+        authType === AuthType.CLOUD_SHELL) {
+        return contentGeneratorConfig;
+    }
+    if (authType === AuthType.USE_GEMINI && geminiApiKey) {
+        contentGeneratorConfig.apiKey = geminiApiKey;
+        contentGeneratorConfig.vertexai = false;
+        return contentGeneratorConfig;
+    }
+    if (authType === AuthType.USE_VERTEX_AI &&
+        (googleApiKey || (googleCloudProject && googleCloudLocation))) {
+        contentGeneratorConfig.apiKey = googleApiKey;
+        contentGeneratorConfig.vertexai = true;
+        return contentGeneratorConfig;
+    }
+    return contentGeneratorConfig;
+}
+async function createContentGenerator(config, gcConfig, sessionId) {
+    const version = process.env['CLI_VERSION'] || process.version;
+    const userAgent = `GeminiCLI/${version} (${process.platform}; ${process.arch})`;
+    const baseHeaders = {
+        'User-Agent': userAgent,
+    };
+    if (config.authType === AuthType.LOGIN_WITH_GOOGLE ||
+        config.authType === AuthType.CLOUD_SHELL) {
+        const httpOptions = { headers: baseHeaders };
+        return (0, codeAssist_1.createCodeAssistContentGenerator)(httpOptions, config.authType, gcConfig, sessionId);
+    }
+    if (config.authType === AuthType.USE_GEMINI ||
+        config.authType === AuthType.USE_VERTEX_AI) {
+        const httpOptions = { headers: baseHeaders };
+        const googleGenAI = new genai_1.GoogleGenAI({
+            apiKey: config.apiKey === '' ? undefined : config.apiKey,
+            vertexai: config.vertexai,
+            httpOptions,
+        });
+        return googleGenAI.models;
+    }
+    throw new Error(`Error creating contentGenerator: Unsupported authType: ${config.authType}`);
+}
+//# sourceMappingURL=contentGenerator.js.map

package/backend/dist/packages/gemini-core/src/core/contentGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentGenerator.js","sourceRoot":"","sources":["../../../../../packages/gemini-core/src/core/contentGenerator.ts"],"names":[],"mappings":"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"}

package/backend/dist/packages/gemini-core/src/core/geminiChat.d.ts

@@ -0,0 +1,34 @@
+import { GenerateContentResponse, type Content, type GenerateContentConfig, type SendMessageParameters, type Part } from '@google/genai';
+import type { Config } from '../config/config';
+export declare enum StreamEventType {
+    CHUNK = "chunk",
+    RETRY = "retry"
+}
+export type StreamEvent = {
+    type: StreamEventType.CHUNK;
+    value: GenerateContentResponse;
+} | {
+    type: StreamEventType.RETRY;
+};
+export declare function isValidNonThoughtTextPart(part: Part): boolean;
+export declare class InvalidStreamError extends Error {
+    readonly type: 'NO_FINISH_REASON' | 'NO_RESPONSE_TEXT';
+    constructor(message: string, type: 'NO_FINISH_REASON' | 'NO_RESPONSE_TEXT');
+}
+export declare class GeminiChat {
+    private readonly config;
+    private readonly generationConfig;
+    private history;
+    private sendPromise;
+    constructor(config: Config, generationConfig?: GenerateContentConfig, history?: Content[]);
+    setSystemInstruction(sysInstr: string): void;
+    sendMessageStream(model: string, params: SendMessageParameters, prompt_id: string): Promise<AsyncGenerator<StreamEvent>>;
+    private makeApiCallAndProcessStream;
+    getHistory(curated?: boolean): Content[];
+    clearHistory(): void;
+    addHistory(content: Content): void;
+    setHistory(history: Content[]): void;
+    private processStreamResponse;
+}
+export declare function isSchemaDepthError(errorMessage: string): boolean;
+export declare function isInvalidArgumentError(errorMessage: string): boolean;

package/backend/dist/packages/gemini-core/src/core/geminiChat.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiChat = exports.InvalidStreamError = exports.StreamEventType = void 0;
+exports.isValidNonThoughtTextPart = isValidNonThoughtTextPart;
+exports.isSchemaDepthError = isSchemaDepthError;
+exports.isInvalidArgumentError = isInvalidArgumentError;
+const genai_1 = require("@google/genai");
+const genai_2 = require("@google/genai");
+const retry_1 = require("../utils/retry");
+const models_1 = require("../config/models");
+var StreamEventType;
+(function (StreamEventType) {
+    StreamEventType["CHUNK"] = "chunk";
+    StreamEventType["RETRY"] = "retry";
+})(StreamEventType || (exports.StreamEventType = StreamEventType = {}));
+const INVALID_CONTENT_RETRY_OPTIONS = {
+    maxAttempts: 2,
+    initialDelayMs: 500,
+};
+function isValidResponse(response) {
+    if (response.candidates === undefined || response.candidates.length === 0) {
+        return false;
+    }
+    const content = response.candidates[0]?.content;
+    if (content === undefined) {
+        return false;
+    }
+    return isValidContent(content);
+}
+function isValidNonThoughtTextPart(part) {
+    return (typeof part.text === 'string' &&
+        !part.thought &&
+        !part.inlineData &&
+        !part.fileData);
+}
+function isValidContent(content) {
+    if (content.parts === undefined || content.parts.length === 0) {
+        return false;
+    }
+    for (const part of content.parts) {
+        if (part === undefined || Object.keys(part).length === 0) {
+            return false;
+        }
+        if (!part.thought && part.text !== undefined && part.text === '') {
+            return false;
+        }
+    }
+    return true;
+}
+function validateHistory(history) {
+    for (const content of history) {
+        if (content.role !== 'user' && content.role !== 'model') {
+            throw new Error(`Role must be user or model, but got ${content.role}.`);
+        }
+    }
+}
+function extractCuratedHistory(comprehensiveHistory) {
+    if (comprehensiveHistory === undefined || comprehensiveHistory.length === 0) {
+        return [];
+    }
+    const curatedHistory = [];
+    const length = comprehensiveHistory.length;
+    let i = 0;
+    while (i < length) {
+        if (comprehensiveHistory[i].role === 'user') {
+            curatedHistory.push(comprehensiveHistory[i]);
+            i++;
+        }
+        else {
+            const modelOutput = [];
+            let isValid = true;
+            while (i < length && comprehensiveHistory[i].role === 'model') {
+                modelOutput.push(comprehensiveHistory[i]);
+                if (isValid && !isValidContent(comprehensiveHistory[i])) {
+                    isValid = false;
+                }
+                i++;
+            }
+            if (isValid) {
+                curatedHistory.push(...modelOutput);
+            }
+        }
+    }
+    return curatedHistory;
+}
+class InvalidStreamError extends Error {
+    constructor(message, type) {
+        super(message);
+        this.name = 'InvalidStreamError';
+        this.type = type;
+    }
+}
+exports.InvalidStreamError = InvalidStreamError;
+class GeminiChat {
+    constructor(config, generationConfig = {}, history = []) {
+        this.config = config;
+        this.generationConfig = generationConfig;
+        this.history = history;
+        this.sendPromise = Promise.resolve();
+        validateHistory(history);
+    }
+    setSystemInstruction(sysInstr) {
+        this.generationConfig.systemInstruction = sysInstr;
+    }
+    async sendMessageStream(model, params, prompt_id) {
+        await this.sendPromise;
+        let streamDoneResolver;
+        const streamDonePromise = new Promise((resolve) => {
+            streamDoneResolver = resolve;
+        });
+        this.sendPromise = streamDonePromise;
+        const userContent = (0, genai_2.createUserContent)(params.message);
+        this.history.push(userContent);
+        const requestContents = this.getHistory(true);
+        const self = this;
+        return (async function* () {
+            try {
+                let lastError = new Error('Request failed after all retries.');
+                for (let attempt = 0; attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts; attempt++) {
+                    try {
+                        if (attempt > 0) {
+                            yield { type: StreamEventType.RETRY };
+                        }
+                        const stream = await self.makeApiCallAndProcessStream(model, requestContents, params, prompt_id);
+                        for await (const chunk of stream) {
+                            yield { type: StreamEventType.CHUNK, value: chunk };
+                        }
+                        lastError = null;
+                        break;
+                    }
+                    catch (error) {
+                        lastError = error;
+                        const isContentError = error instanceof InvalidStreamError;
+                        if (isContentError) {
+                            if (attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts - 1) {
+                                await new Promise((res) => setTimeout(res, INVALID_CONTENT_RETRY_OPTIONS.initialDelayMs *
+                                    (attempt + 1)));
+                                continue;
+                            }
+                        }
+                        break;
+                    }
+                }
+                if (lastError) {
+                    if (self.history[self.history.length - 1] === userContent) {
+                        self.history.pop();
+                    }
+                    throw lastError;
+                }
+            }
+            finally {
+                streamDoneResolver();
+            }
+        })();
+    }
+    async makeApiCallAndProcessStream(model, requestContents, params, prompt_id) {
+        const apiCall = () => {
+            const modelToUse = (0, models_1.getEffectiveModel)(model);
+            return this.config.getContentGenerator().generateContentStream({
+                model: modelToUse,
+                contents: requestContents,
+                config: { ...this.generationConfig, ...params.config },
+            }, prompt_id);
+        };
+        const streamResponse = await (0, retry_1.retryWithBackoff)(apiCall, {
+            shouldRetryOnError: (error) => {
+                if (error instanceof genai_1.ApiError && error.message) {
+                    if (error.status === 400)
+                        return false;
+                    if (isSchemaDepthError(error.message))
+                        return false;
+                    if (error.status === 429)
+                        return true;
+                    if (error.status >= 500 && error.status < 600)
+                        return true;
+                }
+                return false;
+            },
+            authType: this.config.getContentGeneratorConfig()?.authType,
+        });
+        return this.processStreamResponse(model, streamResponse);
+    }
+    getHistory(curated = false) {
+        const history = curated
+            ? extractCuratedHistory(this.history)
+            : this.history;
+        return structuredClone(history);
+    }
+    clearHistory() {
+        this.history = [];
+    }
+    addHistory(content) {
+        this.history.push(content);
+    }
+    setHistory(history) {
+        this.history = history;
+    }
+    async *processStreamResponse(model, streamResponse) {
+        const modelResponseParts = [];
+        let hasFinishReason = false;
+        for await (const chunk of streamResponse) {
+            hasFinishReason =
+                chunk?.candidates?.some((candidate) => candidate.finishReason) ?? false;
+            if (isValidResponse(chunk)) {
+                const content = chunk.candidates?.[0]?.content;
+                if (content?.parts) {
+                    modelResponseParts.push(...content.parts.filter((part) => !part.thought));
+                }
+            }
+            yield chunk;
+        }
+        const consolidatedParts = [];
+        for (const part of modelResponseParts) {
+            const lastPart = consolidatedParts[consolidatedParts.length - 1];
+            if (lastPart?.text &&
+                isValidNonThoughtTextPart(lastPart) &&
+                isValidNonThoughtTextPart(part)) {
+                lastPart.text += part.text;
+            }
+            else {
+                consolidatedParts.push(part);
+            }
+        }
+        const responseText = consolidatedParts
+            .filter((part) => part.text)
+            .map((part) => part.text)
+            .join('')
+            .trim();
+        if (!hasFinishReason || !responseText) {
+            if (!hasFinishReason) {
+                throw new InvalidStreamError('Model stream ended without a finish reason.', 'NO_FINISH_REASON');
+            }
+            else {
+                throw new InvalidStreamError('Model stream ended with empty response text.', 'NO_RESPONSE_TEXT');
+            }
+        }
+        this.history.push({ role: 'model', parts: consolidatedParts });
+    }
+}
+exports.GeminiChat = GeminiChat;
+function isSchemaDepthError(errorMessage) {
+    return errorMessage.includes('maximum schema depth exceeded');
+}
+function isInvalidArgumentError(errorMessage) {
+    return errorMessage.includes('Request contains an invalid argument');
+}
+//# sourceMappingURL=geminiChat.js.map