opencode-gitlab-duo-agentic 0.1.10 → 0.1.12

package/dist/index.d.ts

@@ -1,5 +1,9 @@
-import { Plugin } from '@opencode-ai/plugin';
+import { ProviderV2 } from '@ai-sdk/provider';
+import { Plugin, PluginInput, Hooks } from '@opencode-ai/plugin';
 
+type EntryInput = PluginInput | Record<string, unknown>;
+type EntryOutput = Promise<Hooks> | ProviderV2;
+declare const createGitLabDuoAgentic: (input: EntryInput) => EntryOutput;
 declare const GitLabDuoAgenticPlugin: Plugin;
 
-export { GitLabDuoAgenticPlugin, GitLabDuoAgenticPlugin as default };
+export { GitLabDuoAgenticPlugin, createGitLabDuoAgentic, GitLabDuoAgenticPlugin as default };

package/dist/index.js

@@ -1,14 +1,16 @@
 // src/constants.ts
-var PROVIDER_ID = "gitlab-duo-agentic";
+var PROVIDER_ID = "gitlab";
+var MODEL_ID = "duo-agentic";
 var DEFAULT_INSTANCE_URL = "https://gitlab.com";
+var NOT_IMPLEMENTED_MESSAGE = "GitLab Duo Agentic fallback model is configured, but the Duo Workflow runtime is not implemented yet.";
 
-// src/gitlab.ts
+// src/utils/url.ts
 function text(value) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
-function instanceFromEnv() {
+function envInstanceUrl() {
   return process.env.GITLAB_INSTANCE_URL ?? process.env.GITLAB_URL ?? process.env.GITLAB_BASE_URL;
 }
 function normalizeInstanceUrl(value) {
@@ -21,91 +23,101 @@ function normalizeInstanceUrl(value) {
     return DEFAULT_INSTANCE_URL;
   }
 }
-async function validateToken(instanceUrl, token) {
-  const response = await fetch(`${instanceUrl}/api/v4/user`, {
-    headers: {
-      Authorization: `Bearer ${token}`
-    }
-  }).catch(() => void 0);
-  return !!response?.ok;
-}
-async function persistInstanceUrl(input, instanceUrl) {
-  await input.client.config.update({
-    query: {
-      directory: input.directory
-    },
-    body: {
-      provider: {
-        [PROVIDER_ID]: {
-          options: {
-            instanceUrl
-          }
-        }
-      }
-    }
-  }).catch(() => void 0);
-}
-function applyGitLabConfig(config) {
+
+// src/plugin/config.ts
+function applyRuntimeConfig(config, moduleUrl) {
   config.provider ??= {};
   const current = config.provider[PROVIDER_ID] ?? {};
   const options = current.options ?? {};
-  const instanceUrl = normalizeInstanceUrl(options.instanceUrl ?? instanceFromEnv());
+  const models = current.models ?? {};
+  const instanceUrl = normalizeInstanceUrl(options.instanceUrl ?? envInstanceUrl());
   config.provider[PROVIDER_ID] = {
     ...current,
+    name: current.name ?? "GitLab Duo Agentic",
+    npm: current.npm ?? moduleUrl,
+    env: current.env ?? ["GITLAB_TOKEN", "GITLAB_INSTANCE_URL"],
     options: {
       ...options,
       instanceUrl
+    },
+    models: Object.keys(models).length > 0 ? models : {
+      [MODEL_ID]: {
+        id: MODEL_ID,
+        name: "GitLab Duo Agentic (fallback)"
+      }
     }
   };
+  if (Array.isArray(config.disabled_providers)) {
+    config.disabled_providers = config.disabled_providers.filter((id) => id !== PROVIDER_ID);
+  }
+  if (Array.isArray(config.enabled_providers) && !config.enabled_providers.includes(PROVIDER_ID)) {
+    config.enabled_providers = [...config.enabled_providers, PROVIDER_ID];
+  }
+}
+
+// src/plugin/hooks.ts
+async function createPluginHooks(_input, moduleUrl) {
+  return {
+    config: async (config) => applyRuntimeConfig(config, moduleUrl)
+  };
+}
+
+// src/provider/index.ts
+import { NoSuchModelError, UnsupportedFunctionalityError } from "@ai-sdk/provider";
+function notImplemented() {
+  return new UnsupportedFunctionalityError({
+    functionality: "gitlab-duo-workflow-runtime",
+    message: NOT_IMPLEMENTED_MESSAGE
+  });
 }
-function createGitLabAuthHook(input) {
+function fallbackModel(modelId) {
   return {
+    specificationVersion: "v2",
     provider: PROVIDER_ID,
-    methods: [
-      {
-        type: "api",
-        label: "GitLab Personal Access Token",
-        prompts: [
-          {
-            type: "text",
-            key: "instanceUrl",
-            message: "GitLab instance URL",
-            placeholder: "https://gitlab.com",
-            validate: (value) => text(value) ? void 0 : "Instance URL is required"
-          },
-          {
-            type: "text",
-            key: "token",
-            message: "GitLab token",
-            placeholder: "glpat-...",
-            validate: (value) => text(value) ? void 0 : "Token is required"
-          }
-        ],
-        authorize: async (inputs = {}) => {
-          const token = text(inputs.token);
-          if (!token) return { type: "failed" };
-          const instanceUrl = normalizeInstanceUrl(inputs.instanceUrl ?? instanceFromEnv());
-          const valid = await validateToken(instanceUrl, token);
-          if (!valid) return { type: "failed" };
-          process.env.GITLAB_INSTANCE_URL = instanceUrl;
-          await persistInstanceUrl(input, instanceUrl);
-          return {
-            type: "success",
-            key: token
-          };
-        }
+    modelId,
+    supportedUrls: {},
+    async doGenerate(_options) {
+      throw notImplemented();
+    },
+    async doStream(_options) {
+      throw notImplemented();
+    }
+  };
+}
+function createFallbackProvider() {
+  return {
+    languageModel(modelId) {
+      if (modelId !== MODEL_ID) {
+        throw new NoSuchModelError({ modelId, modelType: "languageModel" });
       }
-    ]
+      return fallbackModel(modelId);
+    },
+    textEmbeddingModel(modelId) {
+      throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+    },
+    imageModel(modelId) {
+      throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+    }
   };
 }
 
 // src/index.ts
-var GitLabDuoAgenticPlugin = async (input) => ({
-  config: async (config) => applyGitLabConfig(config),
-  auth: createGitLabAuthHook(input)
-});
+function isPluginInput(value) {
+  if (!value || typeof value !== "object") return false;
+  const input = value;
+  return "client" in input && "project" in input && "directory" in input && "worktree" in input && "serverUrl" in input;
+}
+var entry = (input) => {
+  if (isPluginInput(input)) {
+    return createPluginHooks(input, import.meta.url);
+  }
+  return createFallbackProvider();
+};
+var createGitLabDuoAgentic = entry;
+var GitLabDuoAgenticPlugin = entry;
 var src_default = GitLabDuoAgenticPlugin;
 export {
   GitLabDuoAgenticPlugin,
+  createGitLabDuoAgentic,
   src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gitlab-duo-agentic",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",