Merge branch 'main' into feat/bwrap-sandbox-v2

Author: Lyonk71

packages/cli/src/config/config.test.ts

@@ -1773,7 +1773,7 @@ describe('loadCliConfig model selection', () => {
   });
 
   it('always prefers model from argv', async () => {
-    process.argv = ['node', 'script.js', '--model', 'gemini-2.5-flash'];
+    process.argv = ['node', 'script.js', '--model', 'gemini-2.5-flash-preview'];
     const argv = await parseArguments(createTestMergedSettings());
     const config = await loadCliConfig(
       createTestMergedSettings({
@@ -1785,11 +1785,11 @@ describe('loadCliConfig model selection', () => {
       argv,
     );
 
-    expect(config.getModel()).toBe('gemini-2.5-flash');
+    expect(config.getModel()).toBe('gemini-2.5-flash-preview');
   });
 
   it('selects the model from argv if provided', async () => {
-    process.argv = ['node', 'script.js', '--model', 'gemini-2.5-flash'];
+    process.argv = ['node', 'script.js', '--model', 'gemini-2.5-flash-preview'];
     const argv = await parseArguments(createTestMergedSettings());
     const config = await loadCliConfig(
       createTestMergedSettings({
@@ -1799,7 +1799,7 @@ describe('loadCliConfig model selection', () => {
       argv,
     );
 
-    expect(config.getModel()).toBe('gemini-2.5-flash');
+    expect(config.getModel()).toBe('gemini-2.5-flash-preview');
   });
 
   it('selects the default auto model if provided via auto alias', async () => {

packages/cli/src/config/config.ts

@@ -31,8 +31,6 @@ import {
   type HierarchicalMemory,
   coreEvents,
   GEMINI_MODEL_ALIAS_AUTO,
-  isValidModelOrAlias,
-  getValidModelsAndAliases,
   getAdminErrorMessage,
   isHeadlessMode,
   Config,
@@ -673,18 +671,6 @@ export async function loadCliConfig(
   const specifiedModel =
     argv.model || process.env['GEMINI_MODEL'] || settings.model?.name;
 
-  // Validate the model if one was explicitly specified
-  if (specifiedModel && specifiedModel !== GEMINI_MODEL_ALIAS_AUTO) {
-    if (!isValidModelOrAlias(specifiedModel)) {
-      const validModels = getValidModelsAndAliases();
-
-      throw new FatalConfigError(
-        `Invalid model: "${specifiedModel}"\n\n` +
-          `Valid models and aliases:\n${validModels.map((m) => `  - ${m}`).join('\n')}\n\n` +
-          `Use /model to switch models interactively.`,
-      );
-    }
-  }
   const resolvedModel =
     specifiedModel === GEMINI_MODEL_ALIAS_AUTO
       ? defaultModel

packages/core/src/agents/agent-scheduler.test.ts

@@ -120,4 +120,25 @@ describe('agent-scheduler', () => {
     expect(schedulerConfig.toolRegistry).toBe(agentRegistry);
     expect(schedulerConfig.toolRegistry).not.toBe(mainRegistry);
   });
+
+  it('should create an AgentLoopContext that has a defined .config property', async () => {
+    const mockConfig = {
+      messageBus: mockMessageBus,
+      toolRegistry: mockToolRegistry,
+      promptId: 'test-prompt',
+    } as unknown as Mocked<Config>;
+
+    const options = {
+      schedulerId: 'subagent-1',
+      toolRegistry: mockToolRegistry as unknown as ToolRegistry,
+      signal: new AbortController().signal,
+    };
+
+    await scheduleAgentTools(mockConfig as unknown as Config, [], options);
+
+    const schedulerContext = vi.mocked(Scheduler).mock.calls[0][0].context;
+    expect(schedulerContext.config).toBeDefined();
+    expect(schedulerContext.config.promptId).toBe('test-prompt');
+    expect(schedulerContext.toolRegistry).toBe(mockToolRegistry);
+  });
 });

packages/core/src/agents/agent-scheduler.ts

@@ -67,8 +67,17 @@ export async function scheduleAgentTools(
     configurable: true,
   });
 
+  const schedulerContext = {
+    config: agentConfig,
+    promptId: config.promptId,
+    toolRegistry,
+    messageBus: toolRegistry.messageBus,
+    geminiClient: config.geminiClient,
+    sandboxManager: config.sandboxManager,
+  };
+
   const scheduler = new Scheduler({
-    context: agentConfig,
+    context: schedulerContext,
     messageBus: toolRegistry.messageBus,
     getPreferredEditor: getPreferredEditor ?? (() => undefined),
     schedulerId,

packages/core/src/config/models.test.ts

@@ -22,7 +22,6 @@ import {
   GEMINI_MODEL_ALIAS_PRO,
   GEMINI_MODEL_ALIAS_FLASH,
   GEMINI_MODEL_ALIAS_AUTO,
-  GEMINI_MODEL_ALIAS_FLASH_LITE,
   PREVIEW_GEMINI_FLASH_MODEL,
   PREVIEW_GEMINI_MODEL_AUTO,
   DEFAULT_GEMINI_MODEL_AUTO,
@@ -31,10 +30,6 @@ import {
   PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL,
   isPreviewModel,
   isProModel,
-  isValidModelOrAlias,
-  getValidModelsAndAliases,
-  VALID_GEMINI_MODELS,
-  VALID_ALIASES,
 } from './models.js';
 
 describe('isPreviewModel', () => {
@@ -394,62 +389,3 @@ describe('isActiveModel', () => {
     ).toBe(false);
   });
 });
-
-describe('isValidModelOrAlias', () => {
-  it('should return true for valid model names', () => {
-    expect(isValidModelOrAlias(DEFAULT_GEMINI_MODEL)).toBe(true);
-    expect(isValidModelOrAlias(PREVIEW_GEMINI_MODEL)).toBe(true);
-    expect(isValidModelOrAlias(DEFAULT_GEMINI_FLASH_MODEL)).toBe(true);
-    expect(isValidModelOrAlias(DEFAULT_GEMINI_FLASH_LITE_MODEL)).toBe(true);
-    expect(isValidModelOrAlias(PREVIEW_GEMINI_FLASH_MODEL)).toBe(true);
-    expect(isValidModelOrAlias(PREVIEW_GEMINI_3_1_MODEL)).toBe(true);
-    expect(isValidModelOrAlias(PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL)).toBe(
-      true,
-    );
-  });
-
-  it('should return true for valid aliases', () => {
-    expect(isValidModelOrAlias(GEMINI_MODEL_ALIAS_AUTO)).toBe(true);
-    expect(isValidModelOrAlias(GEMINI_MODEL_ALIAS_PRO)).toBe(true);
-    expect(isValidModelOrAlias(GEMINI_MODEL_ALIAS_FLASH)).toBe(true);
-    expect(isValidModelOrAlias(GEMINI_MODEL_ALIAS_FLASH_LITE)).toBe(true);
-    expect(isValidModelOrAlias(PREVIEW_GEMINI_MODEL_AUTO)).toBe(true);
-    expect(isValidModelOrAlias(DEFAULT_GEMINI_MODEL_AUTO)).toBe(true);
-  });
-
-  it('should return true for custom (non-gemini) models', () => {
-    expect(isValidModelOrAlias('gpt-4')).toBe(true);
-    expect(isValidModelOrAlias('claude-3')).toBe(true);
-    expect(isValidModelOrAlias('my-custom-model')).toBe(true);
-  });
-
-  it('should return false for invalid gemini model names', () => {
-    expect(isValidModelOrAlias('gemini-4-pro')).toBe(false);
-    expect(isValidModelOrAlias('gemini-99-flash')).toBe(false);
-    expect(isValidModelOrAlias('gemini-invalid')).toBe(false);
-  });
-});
-
-describe('getValidModelsAndAliases', () => {
-  it('should return a sorted array', () => {
-    const result = getValidModelsAndAliases();
-    const sorted = [...result].sort();
-    expect(result).toEqual(sorted);
-  });
-
-  it('should include all valid models and aliases', () => {
-    const result = getValidModelsAndAliases();
-    for (const model of VALID_GEMINI_MODELS) {
-      expect(result).toContain(model);
-    }
-    for (const alias of VALID_ALIASES) {
-      expect(result).toContain(alias);
-    }
-  });
-
-  it('should not contain duplicates', () => {
-    const result = getValidModelsAndAliases();
-    const unique = [...new Set(result)];
-    expect(result).toEqual(unique);
-  });
-});

packages/core/src/config/models.ts

@@ -32,15 +32,6 @@ export const GEMINI_MODEL_ALIAS_PRO = 'pro';
 export const GEMINI_MODEL_ALIAS_FLASH = 'flash';
 export const GEMINI_MODEL_ALIAS_FLASH_LITE = 'flash-lite';
 
-export const VALID_ALIASES = new Set([
-  GEMINI_MODEL_ALIAS_AUTO,
-  GEMINI_MODEL_ALIAS_PRO,
-  GEMINI_MODEL_ALIAS_FLASH,
-  GEMINI_MODEL_ALIAS_FLASH_LITE,
-  PREVIEW_GEMINI_MODEL_AUTO,
-  DEFAULT_GEMINI_MODEL_AUTO,
-]);
-
 export const DEFAULT_GEMINI_EMBEDDING_MODEL = 'gemini-embedding-001';
 
 // Cap the thinking at 8192 to prevent run-away thinking loops.
@@ -292,37 +283,3 @@ export function isActiveModel(
     );
   }
 }
-
-/**
- * Checks if the model name is valid (either a valid model or a valid alias).
- *
- * @param model The model name to check.
- * @returns True if the model is valid.
- */
-export function isValidModelOrAlias(model: string): boolean {
-  // Check if it's a valid alias
-  if (VALID_ALIASES.has(model)) {
-    return true;
-  }
-
-  // Check if it's a valid model name
-  if (VALID_GEMINI_MODELS.has(model)) {
-    return true;
-  }
-
-  // Allow custom models (non-gemini models)
-  if (!model.startsWith('gemini-')) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Gets a list of all valid model names and aliases for error messages.
- *
- * @returns Array of valid model names and aliases.
- */
-export function getValidModelsAndAliases(): string[] {
-  return [...new Set([...VALID_ALIASES, ...VALID_GEMINI_MODELS])].sort();
-}

packages/core/src/config/storage.test.ts

@@ -180,6 +180,25 @@ describe('Storage – additional helpers', () => {
     expect(storageWithSession.getProjectTempPlansDir()).toBe(expected);
   });
 
+  it('getProjectTempTrackerDir returns ~/.gemini/tmp/<identifier>/tracker when no sessionId is provided', async () => {
+    await storage.initialize();
+    const tempDir = storage.getProjectTempDir();
+    const expected = path.join(tempDir, 'tracker');
+    expect(storage.getProjectTempTrackerDir()).toBe(expected);
+  });
+
+  it('getProjectTempTrackerDir returns ~/.gemini/tmp/<identifier>/<sessionId>/tracker when sessionId is provided', async () => {
+    const sessionId = 'test-session-id';
+    const storageWithSession = new Storage(projectRoot, sessionId);
+    ProjectRegistry.prototype.getShortId = vi
+      .fn()
+      .mockReturnValue(PROJECT_SLUG);
+    await storageWithSession.initialize();
+    const tempDir = storageWithSession.getProjectTempDir();
+    const expected = path.join(tempDir, sessionId, 'tracker');
+    expect(storageWithSession.getProjectTempTrackerDir()).toBe(expected);
+  });
+
   describe('Session and JSON Loading', () => {
     beforeEach(async () => {
       await storage.initialize();

packages/core/src/config/storage.ts

@@ -302,6 +302,9 @@ export class Storage {
   }
 
   getProjectTempTrackerDir(): string {
+    if (this.sessionId) {
+      return path.join(this.getProjectTempDir(), this.sessionId, 'tracker');
+    }
     return path.join(this.getProjectTempDir(), 'tracker');
   }
 

packages/core/src/core/coreToolScheduler.ts

@@ -133,7 +133,7 @@ export class CoreToolScheduler {
     this.onAllToolCallsComplete = options.onAllToolCallsComplete;
     this.onToolCallsUpdate = options.onToolCallsUpdate;
     this.getPreferredEditor = options.getPreferredEditor;
-    this.toolExecutor = new ToolExecutor(this.context.config);
+    this.toolExecutor = new ToolExecutor(this.context);
     this.toolModifier = new ToolModificationHandler();
 
     // Subscribe to message bus for ASK_USER policy decisions

packages/core/src/mcp/oauth-utils.test.ts

@@ -272,6 +272,34 @@ describe('OAuthUtils', () => {
         OAuthUtils.discoverOAuthConfig('https://example.com/mcp'),
       ).rejects.toThrow(/does not match expected/);
     });
+
+    it('should accept equivalent root resources with and without trailing slash', async () => {
+      mockFetch
+        // fetchProtectedResourceMetadata
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () =>
+            Promise.resolve({
+              resource: 'https://example.com',
+              authorization_servers: ['https://auth.example.com'],
+              bearer_methods_supported: ['header'],
+            }),
+        })
+        // discoverAuthorizationServerMetadata
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve(mockAuthServerMetadata),
+        });
+
+      await expect(
+        OAuthUtils.discoverOAuthConfig('https://example.com'),
+      ).resolves.toEqual({
+        authorizationUrl: 'https://auth.example.com/authorize',
+        issuer: 'https://auth.example.com',
+        tokenUrl: 'https://auth.example.com/token',
+        scopes: ['read', 'write'],
+      });
+    });
   });
 
   describe('metadataToOAuthConfig', () => {
@@ -336,6 +364,45 @@ describe('OAuthUtils', () => {
     });
   });
 
+  describe('discoverOAuthFromWWWAuthenticate', () => {
+    const mockAuthServerMetadata: OAuthAuthorizationServerMetadata = {
+      issuer: 'https://auth.example.com',
+      authorization_endpoint: 'https://auth.example.com/authorize',
+      token_endpoint: 'https://auth.example.com/token',
+      scopes_supported: ['read', 'write'],
+    };
+
+    it('should accept equivalent root resources with and without trailing slash', async () => {
+      mockFetch
+        // fetchProtectedResourceMetadata(resource_metadata URL)
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () =>
+            Promise.resolve({
+              resource: 'https://example.com',
+              authorization_servers: ['https://auth.example.com'],
+            }),
+        })
+        // discoverAuthorizationServerMetadata(auth server well-known URL)
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve(mockAuthServerMetadata),
+        });
+
+      const result = await OAuthUtils.discoverOAuthFromWWWAuthenticate(
+        'Bearer realm="example", resource_metadata="https://example.com/.well-known/oauth-protected-resource"',
+        'https://example.com/',
+      );
+
+      expect(result).toEqual({
+        authorizationUrl: 'https://auth.example.com/authorize',
+        issuer: 'https://auth.example.com',
+        tokenUrl: 'https://auth.example.com/token',
+        scopes: ['read', 'write'],
+      });
+    });
+  });
+
   describe('extractBaseUrl', () => {
     it('should extract base URL from MCP server URL', () => {
       const result = OAuthUtils.extractBaseUrl('https://example.com/mcp/v1');