gitlab-ai-provider 6.14.0 → 6.15.1

package/dist/index.mjs

@@ -1532,6 +1532,10 @@ var MODEL_MAPPINGS = {
   "duo-chat-opus-4-5": { provider: "anthropic", model: "claude-opus-4-5-20251101" },
   "duo-chat-sonnet-4-5": { provider: "anthropic", model: "claude-sonnet-4-5-20250929" },
   "duo-chat-haiku-4-5": { provider: "anthropic", model: "claude-haiku-4-5-20251001" },
+  // OpenAI models - Responses API
+  // GPT-6 Astra rejects `reasoning_effort` with function tools on Chat Completions;
+  // it must use the Responses API (matches OpenAI's own routing for GPT-5.x/GPT-6).
+  "duo-chat-gpt-6-astra": { provider: "openai", model: "gpt-6-astra", openaiApiType: "responses" },
   // OpenAI models - Chat Completions API
   "duo-chat-gpt-5-1": { provider: "openai", model: "gpt-5.1-2025-11-13", openaiApiType: "chat" },
   "duo-chat-gpt-5-2": { provider: "openai", model: "gpt-5.2-2025-12-11", openaiApiType: "chat" },
@@ -1579,14 +1583,14 @@ var MODEL_MAPPINGS = {
   "duo-workflow-default": { provider: "workflow", model: "default" },
   "duo-workflow-sonnet-4-5": {
     provider: "workflow",
-    model: "anthropic/claude-sonnet-4-5-20250929"
+    model: "claude_sonnet_4_5_20250929"
   },
   "duo-workflow-sonnet-5": { provider: "workflow", model: "claude_sonnet_5" },
   "duo-workflow-opus-5": { provider: "workflow", model: "claude_opus_5" },
   "duo-workflow-sonnet-4-6": { provider: "workflow", model: "claude_sonnet_4_6" },
   "duo-workflow-opus-4-5": {
     provider: "workflow",
-    model: "anthropic/claude-opus-4-5-20251101"
+    model: "claude_opus_4_5_20251101"
   },
   "duo-workflow-haiku-4-5": { provider: "workflow", model: "claude_haiku_4_5_20251001" },
   "duo-workflow-opus-4-6": { provider: "workflow", model: "claude_opus_4_6_20260205" }
@@ -2688,7 +2692,7 @@ import { AsyncResource } from "async_hooks";
 import WebSocket from "isomorphic-ws";
 
 // src/version.ts
-var VERSION = true ? "6.13.0" : "0.0.0-dev";
+var VERSION = true ? "6.15.0" : "0.0.0-dev";
 
 // src/gitlab-workflow-client.ts
 var WS_CONNECT_TIMEOUT_MS = 3e4;
@@ -3408,8 +3412,14 @@ var GitLabProjectDetector = class {
 };
 
 // src/gitlab-model-discovery.ts
+function scopeCacheKey(scope) {
+  return "projectId" in scope ? `p:${scope.projectId}` : `n:${scope.rootNamespaceId}`;
+}
+function normalizeScope(scope) {
+  return typeof scope === "string" ? { rootNamespaceId: scope } : scope;
+}
 var AI_CHAT_AVAILABLE_MODELS_QUERY = `
-  query aiChatAvailableModels($rootNamespaceId: GroupID!) {
+  query aiChatAvailableModels($projectId: ProjectID, $rootNamespaceId: GroupID) {
     metadata {
       featureFlags(names: ["ai_user_model_switching"]) {
         enabled
@@ -3418,7 +3428,7 @@ var AI_CHAT_AVAILABLE_MODELS_QUERY = `
       version
     }
 
-    aiChatAvailableModels(rootNamespaceId: $rootNamespaceId) {
+    aiChatAvailableModels(projectId: $projectId, rootNamespaceId: $rootNamespaceId) {
       defaultModel {
         name
         ref
@@ -3444,18 +3454,42 @@ var GitLabModelDiscovery = class {
     this.fetchFn = config.fetch ?? fetch;
   }
   /**
-   * Discover available models for a given root namespace.
+   * Discover available models for a given project or root namespace.
    *
-   * Results are cached per `rootNamespaceId` with a 10-minute TTL.
+   * Results are cached per scope with a 10-minute TTL.
    * Use `invalidateCache()` to force an immediate refresh.
    *
-   * @param rootNamespaceId - GitLab group ID (e.g., 'gid://gitlab/Group/12345')
+   * @param scope - `{ projectId }` (preferred), `{ rootNamespaceId }`, or a
+   *   bare string (treated as `rootNamespaceId` for backwards compatibility)
    */
-  async discover(rootNamespaceId) {
-    const cached = this.cache.get(rootNamespaceId);
+  async discover(scope) {
+    const normalized = normalizeScope(scope);
+    const cacheKey = scopeCacheKey(normalized);
+    const cached = this.cache.get(cacheKey);
     if (cached && cached.expiresAt > Date.now()) {
       return cached.data;
     }
+    try {
+      const result = await this.query(normalized);
+      this.cache.set(cacheKey, {
+        data: result,
+        expiresAt: Date.now() + DISCOVERY_CACHE_TTL_MS
+      });
+      return result;
+    } catch (error) {
+      if ("projectId" in normalized && normalized.rootNamespaceId) {
+        const fallbackScope = { rootNamespaceId: normalized.rootNamespaceId };
+        const result = await this.query(fallbackScope);
+        this.cache.set(scopeCacheKey(fallbackScope), {
+          data: result,
+          expiresAt: Date.now() + DISCOVERY_CACHE_TTL_MS
+        });
+        return result;
+      }
+      throw error;
+    }
+  }
+  async query(scope) {
     const url = `${this.config.instanceUrl}/api/graphql`;
     try {
       const response = await this.fetchFn(url, {
@@ -3466,7 +3500,7 @@ var GitLabModelDiscovery = class {
         },
         body: JSON.stringify({
           query: AI_CHAT_AVAILABLE_MODELS_QUERY,
-          variables: { rootNamespaceId }
+          variables: "projectId" in scope ? { projectId: scope.projectId, rootNamespaceId: void 0 } : { projectId: void 0, rootNamespaceId: scope.rootNamespaceId }
         })
       });
       if (!response.ok) {
@@ -3485,19 +3519,15 @@ var GitLabModelDiscovery = class {
       }
       const models = json.data?.aiChatAvailableModels;
       const metadata = json.data?.metadata;
-      const modelSwitchingEnabled = metadata?.featureFlags?.find((f) => f.name === "ai_user_model_switching")?.enabled ?? false;
-      const result = {
+      const flag = metadata?.featureFlags?.find((f) => f.name === "ai_user_model_switching");
+      const modelSwitchingEnabled = flag ? flag.enabled : true;
+      return {
         defaultModel: models?.defaultModel ?? null,
         selectableModels: models?.selectableModels ?? [],
         pinnedModel: models?.pinnedModel ?? null,
         modelSwitchingEnabled,
         instanceVersion: metadata?.version ?? null
       };
-      this.cache.set(rootNamespaceId, {
-        data: result,
-        expiresAt: Date.now() + DISCOVERY_CACHE_TTL_MS
-      });
-      return result;
     } catch (error) {
       if (error instanceof GitLabError) throw error;
       throw new GitLabError({
@@ -3511,11 +3541,11 @@ var GitLabModelDiscovery = class {
    *
    * Priority: pinned > user-selected > default.
    *
-   * @param rootNamespaceId - GitLab group ID
+   * @param scope - Project or root namespace to discover models for
    * @param userSelectedRef - Optional user preference
    */
-  async getEffectiveModelRef(rootNamespaceId, userSelectedRef) {
-    const discovered = await this.discover(rootNamespaceId);
+  async getEffectiveModelRef(scope, userSelectedRef) {
+    const discovered = await this.discover(scope);
     if (discovered.pinnedModel) {
       return discovered.pinnedModel.ref;
     }
@@ -3962,6 +3992,25 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
     this._rootNamespaceId = null;
     return null;
   }
+  /**
+   * Resolve the model discovery scope to use for `aiChatAvailableModels`.
+   *
+   * `projectId` is preferred — it works for both group- and user-namespace
+   * projects — with `rootNamespaceId` attached as a fallback for GitLab
+   * instances too old to support `projectId`-scoped discovery.
+   */
+  async resolveDiscoveryScope() {
+    const rootNamespaceId = await this.resolveRootNamespaceId();
+    const workDir = this.workflowOptions.workingDirectory ?? process.cwd();
+    const project = await this.projectDetector.detectProject(workDir);
+    if (project?.id) {
+      return {
+        projectId: `gid://gitlab/Project/${project.id}`,
+        ...rootNamespaceId ? { rootNamespaceId } : {}
+      };
+    }
+    return rootNamespaceId ? { rootNamespaceId } : null;
+  }
   /**
    * Resolve the effective DWS model ref to use for this stream.
    * Deduplicates concurrent calls via a shared promise.
@@ -3992,13 +4041,13 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
     return this._discoveryPromise;
   }
   async doResolveModelRef() {
-    const rootNamespaceId = await this.resolveRootNamespaceId();
-    if (!rootNamespaceId) {
+    const scope = await this.resolveDiscoveryScope();
+    if (!scope) {
       this._selectedModelRef = "default";
       return "default";
     }
     try {
-      const discovered = await this.modelDiscovery.discover(rootNamespaceId);
+      const discovered = await this.modelDiscovery.discover(scope);
       this.modelCache.saveDiscovery(discovered);
       if (discovered.pinnedModel) {
         this._selectedModelRef = discovered.pinnedModel.ref;
@@ -4041,11 +4090,13 @@ var GitLabWorkflowLanguageModel = class _GitLabWorkflowLanguageModel {
    * Call this early (e.g., on IDE startup) to avoid blocking the first stream.
    * Results are persisted to the workspace model cache.
    *
-   * @param rootNamespaceId - GitLab group ID (e.g., 'gid://gitlab/Group/12345')
+   * @param scope - Project or root namespace GID to discover models for.
+   *   A bare string is treated as a `rootNamespaceId` (e.g.
+   *   'gid://gitlab/Group/12345') for backwards compatibility.
    * @returns Discovered models with default, selectable, and pinned models
    */
-  async discoverModels(rootNamespaceId) {
-    const result = await this.modelDiscovery.discover(rootNamespaceId);
+  async discoverModels(scope) {
+    const result = await this.modelDiscovery.discover(scope);
     this.modelCache.saveDiscovery(result);
     return result;
   }
@@ -5787,7 +5838,7 @@ async function buildModels(discovered, project) {
   for (const model of all) {
     if (!model.ref || seen.has(model.ref)) continue;
     seen.add(model.ref);
-    const id = refToID.get(model.ref) ?? `duo-workflow-${model.ref.replace(/[/_]/g, "-")}`;
+    const id = refToID.get(model.ref) ?? (model.ref.startsWith("__default__") ? "duo-workflow-default" : `duo-workflow-${model.ref.replace(/[/_]/g, "-")}`);
     const limits = configs.get(model.ref);
     models.push({
       id,
@@ -5819,14 +5870,22 @@ async function discoverWorkflowModels(config, options) {
   } catch {
     return { models: [], project: null };
   }
-  const namespaceId = project?.namespaceId;
-  if (!namespaceId) return { models: [], project };
+  if (!project?.id) return { models: [], project };
+  const scope = {
+    projectId: `gid://gitlab/Project/${project.id}`,
+    ...project.namespaceId ? { rootNamespaceId: `gid://gitlab/Group/${project.namespaceId}` } : {}
+  };
   const discovery = new GitLabModelDiscovery({
     instanceUrl: config.instanceUrl,
     getHeaders: config.getHeaders,
     fetch: config.fetch
   });
-  const discovered = await discovery.discover(`gid://gitlab/Group/${namespaceId}`);
+  let discovered;
+  try {
+    discovered = await discovery.discover(scope);
+  } catch {
+    return { models: [], project };
+  }
   cache.saveDiscovery(discovered, project);
   if (!cache.getSelectedModelRef()) {
     const pick = discovered.pinnedModel ?? discovered.defaultModel;