repoburg 1.0.69 → 1.1.0

package/backend/packages/gemini-core/examples/simple.ts

@@ -0,0 +1,120 @@
+import { randomUUID } from 'crypto';
+import {
+  Content,
+  GenerateContentConfig,
+  GenerateContentResponse,
+} from '@google/genai';
+import { AuthType, Config, GeminiChat, StreamEventType } from '../src';
+
+/**
+ * A helper function to extract the text content from a streaming response chunk.
+ * The Gemini API streams responses, and this function helps aggregate the text.
+ * @param response A GenerateContentResponse chunk from the stream.
+ * @returns The text content of the chunk, or null if there is none.
+ */
+function getResponseText(response: GenerateContentResponse): string | null {
+  if (response.candidates && response.candidates.length > 0) {
+    const candidate = response.candidates[0];
+
+    if (
+      candidate.content &&
+      candidate.content.parts &&
+      candidate.content.parts.length > 0
+    ) {
+      return candidate.content.parts
+        .filter((part: any) => part.text)
+        .map((part: any) => part.text)
+        .join('');
+    }
+  }
+  return null;
+}
+
+async function main() {
+  console.log('--- Gemini Chat API Example (with Google Login) ---');
+
+  // 1. Set up for Google Login
+  // For this example, we'll authenticate using your Google account.
+  // The first time you run this, a browser window will open for you to log in.
+  // Your credentials will be cached for future runs in `~/.gemini/`.
+  console.log('✓ Using Google Login for authentication.');
+
+  // 2. Create a Configuration Object
+  // The Config object holds settings for the session. For this example,
+  // we provide a few essential parameters.
+  const config = new Config({
+    sessionId: `session-${randomUUID()}`,
+    model: 'gemini-2.5-pro', // A default model for the session
+  });
+  console.log('✓ Configuration created.');
+
+  // 3. Authenticate and Prepare the API Client (ContentGenerator)
+  // The GeminiChat class relies on a `ContentGenerator` instance being available
+  // on the Config object to make API calls. `refreshAuth` sets this up.
+  try {
+    // This will trigger the OAuth2 flow in the browser on the first run.
+    await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+  } catch (e) {
+    console.error('Authentication failed:', e);
+    return;
+  }
+  console.log('✓ Authenticated with your Google account.');
+
+  // 4. Define System Instruction and Conversation History
+  const systemInstruction =
+    'You are a poetic assistant. All your responses must be in the form of a haiku.';
+
+  const initialHistory: Content[] = [
+    { role: 'user', parts: [{ text: 'What is the largest mammal?' }] },
+    {
+      role: 'model',
+      parts: [
+        {
+          text: "Giant blue whale swims,\nOcean's gentle, massive king,\nLargest on the Earth.",
+        },
+      ],
+    },
+  ];
+
+  const generationConfig: GenerateContentConfig = {
+    systemInstruction,
+    temperature: 0.7,
+  };
+  console.log('✓ System instruction and history prepared.');
+
+  // 5. Instantiate GeminiChat
+  // We provide the config, generation settings (with system instruction), and initial history.
+  const chat = new GeminiChat(config, generationConfig, initialHistory);
+  console.log('✓ GeminiChat instance created.');
+
+  // 6. Send a New Message with History and System Instruction
+  console.log('\nUser: How much does it weigh?');
+  const responseStream = await chat.sendMessageStream(
+    'gemini-2.5-pro', // You can specify a model here to override the config default for this call
+    { message: 'How much does it weigh?' },
+    `prompt-${randomUUID()}`,
+  );
+
+  // 7. Process and Display the Streaming Response
+  let fullResponse = '';
+  process.stdout.write('Gemini: ');
+  for await (const chunk of responseStream) {
+    // The stream yields events. We are interested in 'chunk' events which contain response data.
+    if (chunk.type === StreamEventType.CHUNK && chunk.value) {
+      const text = getResponseText(chunk.value);
+      if (text) {
+        process.stdout.write(text);
+        fullResponse += text;
+      }
+    }
+  }
+  console.log(); // Newline after the stream ends
+
+  // 8. Verify the updated history
+  // The chat history now contains the full conversation, including the latest turn.
+  console.log('\n--- Full Conversation History ---');
+  console.log(JSON.stringify(chat.getHistory(), null, 2));
+  console.log('--- End of Example ---');
+}
+
+main().catch(console.error);

package/backend/packages/gemini-core/index.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from './src/index';
+export { Storage } from './src/config/storage';
+export {
+  DEFAULT_GEMINI_MODEL,
+  DEFAULT_GEMINI_MODEL_AUTO,
+  DEFAULT_GEMINI_FLASH_MODEL,
+  DEFAULT_GEMINI_FLASH_LITE_MODEL,
+  DEFAULT_GEMINI_EMBEDDING_MODEL,
+} from './src/config/models';

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

@@ -0,0 +1,37 @@
+/**
+ * @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

@@ -0,0 +1,250 @@
+/**
+ * @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

@@ -0,0 +1,129 @@
+/**
+ * @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;
+  }
+}