repoburg 1.3.136 → 1.3.138

package/backend/packages/gemini-core/src/code_assist/codeAssist.ts

@@ -1,37 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type { ContentGenerator } from '../core/contentGenerator';
-import { AuthType } from '../core/contentGenerator';
-import { getOauthClient } from './oauth2';
-import { setupUser } from './setup';
-import type { HttpOptions } from './server';
-import { CodeAssistServer } from './server';
-import type { Config } from '../config/config';
-
-export async function createCodeAssistContentGenerator(
-  httpOptions: HttpOptions,
-  authType: AuthType,
-  config: Config,
-  sessionId?: string,
-): Promise<ContentGenerator> {
-  if (
-    authType === AuthType.LOGIN_WITH_GOOGLE ||
-    authType === AuthType.CLOUD_SHELL
-  ) {
-    const authClient = await getOauthClient(authType, config);
-    const userData = await setupUser(authClient);
-    return new CodeAssistServer(
-      authClient,
-      userData.projectId,
-      httpOptions,
-      sessionId,
-      userData.userTier,
-    );
-  }
-
-  throw new Error(`Unsupported authType: ${authType}`);
-}

package/backend/packages/gemini-core/src/code_assist/converter.ts

@@ -1,250 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type {
-  Content,
-  ContentListUnion,
-  ContentUnion,
-  GenerateContentConfig,
-  GenerateContentParameters,
-  CountTokensParameters,
-  CountTokensResponse,
-  GenerationConfigRoutingConfig,
-  MediaResolution,
-  Candidate,
-  ModelSelectionConfig,
-  GenerateContentResponsePromptFeedback,
-  GenerateContentResponseUsageMetadata,
-  Part,
-  SafetySetting,
-  PartUnion,
-  SpeechConfigUnion,
-  ThinkingConfig,
-  ToolListUnion,
-  ToolConfig,
-} from '@google/genai';
-import { GenerateContentResponse } from '@google/genai';
-
-export interface CAGenerateContentRequest {
-  model: string;
-  project?: string;
-  user_prompt_id?: string;
-  request: VertexGenerateContentRequest;
-}
-
-interface VertexGenerateContentRequest {
-  contents: Content[];
-  systemInstruction?: Content;
-  cachedContent?: string;
-  tools?: ToolListUnion;
-  toolConfig?: ToolConfig;
-  labels?: Record<string, string>;
-  safetySettings?: SafetySetting[];
-  generationConfig?: VertexGenerationConfig;
-  session_id?: string;
-}
-
-interface VertexGenerationConfig {
-  temperature?: number;
-  topP?: number;
-  topK?: number;
-  candidateCount?: number;
-  maxOutputTokens?: number;
-  stopSequences?: string[];
-  responseLogprobs?: boolean;
-  logprobs?: number;
-  presencePenalty?: number;
-  frequencyPenalty?: number;
-  seed?: number;
-  responseMimeType?: string;
-  responseJsonSchema?: unknown;
-  responseSchema?: unknown;
-  routingConfig?: GenerationConfigRoutingConfig;
-  modelSelectionConfig?: ModelSelectionConfig;
-  responseModalities?: string[];
-  mediaResolution?: MediaResolution;
-  speechConfig?: SpeechConfigUnion;
-  audioTimestamp?: boolean;
-  thinkingConfig?: ThinkingConfig;
-}
-
-export interface CaGenerateContentResponse {
-  response: VertexGenerateContentResponse;
-}
-
-interface VertexGenerateContentResponse {
-  candidates: Candidate[];
-  automaticFunctionCallingHistory?: Content[];
-  promptFeedback?: GenerateContentResponsePromptFeedback;
-  usageMetadata?: GenerateContentResponseUsageMetadata;
-  modelVersion?: string;
-}
-
-export interface CaCountTokenRequest {
-  request: VertexCountTokenRequest;
-}
-
-interface VertexCountTokenRequest {
-  model: string;
-  contents: Content[];
-}
-
-export interface CaCountTokenResponse {
-  totalTokens: number;
-}
-
-export function toCountTokenRequest(
-  req: CountTokensParameters,
-): CaCountTokenRequest {
-  return {
-    request: {
-      model: 'models/' + req.model,
-      contents: toContents(req.contents),
-    },
-  };
-}
-
-export function fromCountTokenResponse(
-  res: CaCountTokenResponse,
-): CountTokensResponse {
-  return {
-    totalTokens: res.totalTokens,
-  };
-}
-
-export function toGenerateContentRequest(
-  req: GenerateContentParameters,
-  userPromptId: string,
-  project?: string,
-  sessionId?: string,
-): CAGenerateContentRequest {
-  return {
-    model: req.model,
-    project,
-    user_prompt_id: userPromptId,
-    request: toVertexGenerateContentRequest(req, sessionId),
-  };
-}
-
-export function fromGenerateContentResponse(
-  res: CaGenerateContentResponse,
-): GenerateContentResponse {
-  const inres = res.response;
-  const out = new GenerateContentResponse();
-  out.candidates = inres.candidates;
-  out.automaticFunctionCallingHistory = inres.automaticFunctionCallingHistory;
-  out.promptFeedback = inres.promptFeedback;
-  out.usageMetadata = inres.usageMetadata;
-  out.modelVersion = inres.modelVersion;
-  return out;
-}
-
-function toVertexGenerateContentRequest(
-  req: GenerateContentParameters,
-  sessionId?: string,
-): VertexGenerateContentRequest {
-  return {
-    contents: toContents(req.contents),
-    systemInstruction: maybeToContent(req.config?.systemInstruction),
-    cachedContent: req.config?.cachedContent,
-    tools: req.config?.tools,
-    toolConfig: req.config?.toolConfig,
-    labels: req.config?.labels,
-    safetySettings: req.config?.safetySettings,
-    generationConfig: toVertexGenerationConfig(req.config),
-    session_id: sessionId,
-  };
-}
-
-export function toContents(contents: ContentListUnion): Content[] {
-  if (Array.isArray(contents)) {
-    // it's a Content[] or a PartsUnion[]
-    return contents.map(toContent);
-  }
-  // it's a Content or a PartsUnion
-  return [toContent(contents)];
-}
-
-function maybeToContent(content?: ContentUnion): Content | undefined {
-  if (!content) {
-    return undefined;
-  }
-  return toContent(content);
-}
-
-function toContent(content: ContentUnion): Content {
-  if (Array.isArray(content)) {
-    // it's a PartsUnion[]
-    return {
-      role: 'user',
-      parts: toParts(content),
-    };
-  }
-  if (typeof content === 'string') {
-    // it's a string
-    return {
-      role: 'user',
-      parts: [{ text: content }],
-    };
-  }
-  if ('parts' in content) {
-    // it's a Content - process parts to handle thought filtering
-    return {
-      ...content,
-      parts: content.parts
-        ? toParts(content.parts.filter((p) => p != null))
-        : [],
-    };
-  }
-  // it's a Part
-  return {
-    role: 'user',
-    parts: [toPart(content as Part)],
-  };
-}
-
-export function toParts(parts: PartUnion[]): Part[] {
-  return parts.map(toPart);
-}
-
-function toPart(part: PartUnion): Part {
-  if (typeof part === 'string') {
-    // it's a string
-    return { text: part };
-  }
-  return part;
-}
-
-function toVertexGenerationConfig(
-  config?: GenerateContentConfig,
-): VertexGenerationConfig | undefined {
-  if (!config) {
-    return undefined;
-  }
-  return {
-    temperature: config.temperature,
-    topP: config.topP,
-    topK: config.topK,
-    candidateCount: config.candidateCount,
-    maxOutputTokens: config.maxOutputTokens,
-    stopSequences: config.stopSequences,
-    responseLogprobs: config.responseLogprobs,
-    logprobs: config.logprobs,
-    presencePenalty: config.presencePenalty,
-    frequencyPenalty: config.frequencyPenalty,
-    seed: config.seed,
-    responseMimeType: config.responseMimeType,
-    responseSchema: config.responseSchema,
-    responseJsonSchema: config.responseJsonSchema,
-    routingConfig: config.routingConfig,
-    modelSelectionConfig: config.modelSelectionConfig,
-    responseModalities: config.responseModalities,
-    mediaResolution: config.mediaResolution,
-    speechConfig: config.speechConfig,
-    audioTimestamp: config.audioTimestamp,
-    thinkingConfig: config.thinkingConfig,
-  };
-}

package/backend/packages/gemini-core/src/code_assist/oauth-credential-storage.ts

@@ -1,129 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { type Credentials } from 'google-auth-library';
-import { HybridTokenStorage } from '../mcp/token-storage/hybrid-token-storage';
-import { OAUTH_FILE, GEMINI_DIR, Storage } from '../config/storage';
-import type { OAuthCredentials } from '../mcp/token-storage/types';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { promises as fs } from 'node:fs';
-
-const KEYCHAIN_SERVICE_NAME = 'gemini-cli-oauth';
-const MAIN_ACCOUNT_KEY = 'main-account';
-
-export class OAuthCredentialStorage {
-  private static storage: HybridTokenStorage = new HybridTokenStorage(
-    KEYCHAIN_SERVICE_NAME,
-  );
-
-  /**
-   * Load cached OAuth credentials
-   */
-  static async loadCredentials(): Promise<Credentials | null> {
-    try {
-      const credentials = await this.storage.getCredentials(MAIN_ACCOUNT_KEY);
-
-      if (credentials?.token) {
-        const { accessToken, refreshToken, expiresAt, tokenType, scope } =
-          credentials.token;
-        // Convert from OAuthCredentials format to Google Credentials format
-        const googleCreds: Credentials = {
-          access_token: accessToken,
-          refresh_token: refreshToken || undefined,
-          token_type: tokenType || undefined,
-          scope: scope || undefined,
-        };
-
-        if (expiresAt) {
-          googleCreds.expiry_date = expiresAt;
-        }
-
-        return googleCreds;
-      }
-
-      // Fallback: Try to migrate from old file-based storage
-      return await this.migrateFromFileStorage();
-    } catch (error: unknown) {
-      console.error(error);
-      throw new Error('Failed to load OAuth credentials');
-    }
-  }
-
-  /**
-   * Save OAuth credentials
-   */
-  static async saveCredentials(credentials: Credentials): Promise<void> {
-    if (!credentials.access_token) {
-      throw new Error('Attempted to save credentials without an access token.');
-    }
-
-    // Convert Google Credentials to OAuthCredentials format
-    const mcpCredentials: OAuthCredentials = {
-      serverName: MAIN_ACCOUNT_KEY,
-      token: {
-        accessToken: credentials.access_token,
-        refreshToken: credentials.refresh_token || undefined,
-        tokenType: credentials.token_type || 'Bearer',
-        scope: credentials.scope || undefined,
-        expiresAt: credentials.expiry_date || undefined,
-      },
-      updatedAt: Date.now(),
-    };
-
-    await this.storage.setCredentials(mcpCredentials);
-  }
-
-  /**
-   * Clear cached OAuth credentials
-   */
-  static async clearCredentials(): Promise<void> {
-    try {
-      await this.storage.deleteCredentials(MAIN_ACCOUNT_KEY);
-
-      // Also try to remove the old file if it exists
-      const oldFilePath = Storage.getOAuthCredsPath();
-      await fs.rm(oldFilePath, { force: true }).catch(() => {});
-    } catch (error: unknown) {
-      console.error(error);
-      throw new Error('Failed to clear OAuth credentials');
-    }
-  }
-
-  /**
-   * Migrate credentials from old file-based storage to keychain
-   */
-  private static async migrateFromFileStorage(): Promise<Credentials | null> {
-    const oldFilePath = Storage.getOAuthCredsPath();
-
-    let credsJson: string;
-    try {
-      credsJson = await fs.readFile(oldFilePath, 'utf-8');
-    } catch (error: unknown) {
-      if (
-        typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        error.code === 'ENOENT'
-      ) {
-        // File doesn't exist, so no migration.
-        return null;
-      }
-      // Other read errors should propagate.
-      throw error;
-    }
-
-    const credentials = JSON.parse(credsJson) as Credentials;
-
-    // Save to new storage
-    await this.saveCredentials(credentials);
-
-    // Remove old file after successful migration
-    await fs.rm(oldFilePath, { force: true }).catch(() => {});
-
-    return credentials;
-  }
-}