opencode-gitlab-duo-agentic 0.1.15 → 0.1.17

package/dist/index.js

@@ -3,7 +3,14 @@ var PROVIDER_ID = "gitlab";
 var DEFAULT_MODEL_ID = "duo-chat-sonnet-4-5";
 var DEFAULT_INSTANCE_URL = "https://gitlab.com";
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-var NOT_IMPLEMENTED_MESSAGE = "GitLab Duo Agentic fallback model is configured, but the Duo Workflow runtime is not implemented yet.";
+var WORKFLOW_DEFINITION = "chat";
+var WORKFLOW_CLIENT_VERSION = "1.0";
+var WORKFLOW_ENVIRONMENT = "ide";
+var WORKFLOW_CONNECT_TIMEOUT_MS = 15e3;
+var WORKFLOW_HEARTBEAT_INTERVAL_MS = 6e4;
+var WORKFLOW_KEEPALIVE_INTERVAL_MS = 45e3;
+var WORKFLOW_TOKEN_EXPIRY_BUFFER_MS = 3e4;
+var WORKFLOW_TOOL_ERROR_MESSAGE = "Tool execution is not implemented in this client yet";
 
 // src/gitlab/models.ts
 import crypto from "crypto";
@@ -19,17 +26,38 @@ var GitLabApiError = class extends Error {
     this.name = "GitLabApiError";
   }
 };
-async function get(options, path3) {
+async function request(options, path3, init) {
   const url = `${options.instanceUrl}/api/v4/${path3}`;
+  const headers = new Headers(init.headers);
+  headers.set("authorization", `Bearer ${options.token}`);
   const response = await fetch(url, {
-    headers: { authorization: `Bearer ${options.token}` }
+    ...init,
+    headers
   });
+  return response;
+}
+async function get(options, path3) {
+  const response = await request(options, path3, { method: "GET" });
   if (!response.ok) {
     const text2 = await response.text().catch(() => "");
     throw new GitLabApiError(response.status, `GET ${path3} failed (${response.status}): ${text2}`);
   }
   return response.json();
 }
+async function post(options, path3, body) {
+  const response = await request(options, path3, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text2 = await response.text().catch(() => "");
+    throw new GitLabApiError(response.status, `POST ${path3} failed (${response.status}): ${text2}`);
+  }
+  return response.json();
+}
 async function graphql(options, query, variables) {
   const url = `${options.instanceUrl}/api/graphql`;
   const response = await fetch(url, {
@@ -264,12 +292,13 @@ async function applyRuntimeConfig(config, directory) {
   const current = config.provider[PROVIDER_ID] ?? {};
   const options = current.options ?? {};
   const instanceUrl = normalizeInstanceUrl(options.instanceUrl ?? envInstanceUrl());
-  const token = (typeof options.apiKey === "string" ? options.apiKey : void 0) ?? process.env.GITLAB_TOKEN ?? "";
+  const token = (typeof options.apiKey === "string" ? options.apiKey : void 0) ?? process.env.GITLAB_TOKEN ?? process.env.GITLAB_OAUTH_TOKEN ?? "";
   const available = await loadAvailableModels(instanceUrl, token, directory);
   const modelIds = available.map((m) => m.id);
   const models = toModelsConfig(available);
   config.provider[PROVIDER_ID] = {
     ...current,
+    npm: "opencode-gitlab-duo-agentic",
     whitelist: modelIds,
     options: {
       ...options,
@@ -292,36 +321,563 @@ function toModelsConfig(available) {
 // src/plugin/hooks.ts
 async function createPluginHooks(input) {
   return {
-    config: async (config) => applyRuntimeConfig(config, input.directory)
+    config: async (config) => applyRuntimeConfig(config, input.directory),
+    "chat.params": async (context, output) => {
+      if (!isGitLabProvider(context.model)) return;
+      output.options = {
+        ...output.options,
+        workflowSessionID: context.sessionID
+      };
+    },
+    "chat.headers": async (context, output) => {
+      if (!isGitLabProvider(context.model)) return;
+      output.headers = {
+        ...output.headers,
+        "x-opencode-session": context.sessionID
+      };
+    }
   };
 }
+function isGitLabProvider(model) {
+  if (model.api?.npm === "opencode-gitlab-duo-agentic") return true;
+  if (model.providerID === "gitlab" && model.api?.npm !== "@gitlab/gitlab-ai-provider") return true;
+  return model.providerID.toLowerCase().includes("gitlab-duo");
+}
 
 // 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 placeholderModel(modelId) {
+import { NoSuchModelError } from "@ai-sdk/provider";
+
+// src/provider/duo-workflow-model.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/workflow/session.ts
+import { randomUUID } from "crypto";
+
+// src/workflow/checkpoint.ts
+function createCheckpointState() {
   return {
-    specificationVersion: "v2",
-    provider: PROVIDER_ID,
-    modelId,
-    supportedUrls: {},
-    async doGenerate(_options) {
-      throw notImplemented();
-    },
-    async doStream(_options) {
-      throw notImplemented();
-    }
+    uiChatLog: []
   };
 }
-function createFallbackProvider() {
+function extractAgentTextDeltas(checkpoint, state) {
+  const next = parseCheckpoint(checkpoint);
+  const out = [];
+  for (let i = 0; i < next.length; i++) {
+    const item = next[i];
+    if (item.message_type !== "agent") continue;
+    const previous = state.uiChatLog[i];
+    if (!previous || previous.message_type !== "agent") {
+      if (item.content) out.push(item.content);
+      continue;
+    }
+    if (item.content === previous.content) continue;
+    if (item.content.startsWith(previous.content)) {
+      const delta = item.content.slice(previous.content.length);
+      if (delta) out.push(delta);
+      continue;
+    }
+    if (item.content) out.push(item.content);
+  }
+  state.uiChatLog = next;
+  return out;
+}
+function parseCheckpoint(raw) {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    const log = parsed.channel_values?.ui_chat_log;
+    if (!Array.isArray(log)) return [];
+    return log.filter(isUiChatLogEntry);
+  } catch {
+    return [];
+  }
+}
+function isUiChatLogEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  const item = value;
+  if (typeof item.message_type !== "string") return false;
+  if (typeof item.content !== "string") return false;
+  return item.message_type === "user" || item.message_type === "agent" || item.message_type === "tool" || item.message_type === "request";
+}
+
+// src/workflow/token-service.ts
+var WorkflowTokenService = class {
+  #client;
+  #cache = /* @__PURE__ */ new Map();
+  constructor(client) {
+    this.#client = client;
+  }
+  clear() {
+    this.#cache.clear();
+  }
+  async get(rootNamespaceId) {
+    const key = rootNamespaceId ?? "";
+    const cached = this.#cache.get(key);
+    if (cached && cached.expiresAt > Date.now()) return cached.value;
+    try {
+      const value = await post(
+        this.#client,
+        "ai/duo_workflows/direct_access",
+        rootNamespaceId ? {
+          workflow_definition: WORKFLOW_DEFINITION,
+          root_namespace_id: rootNamespaceId
+        } : {
+          workflow_definition: WORKFLOW_DEFINITION
+        }
+      );
+      const expiresAt = readExpiry(value);
+      this.#cache.set(key, { value, expiresAt });
+      return value;
+    } catch {
+      return null;
+    }
+  }
+};
+function readExpiry(value) {
+  const workflowExpiry = typeof value.duo_workflow_service?.token_expires_at === "number" ? value.duo_workflow_service.token_expires_at * 1e3 : Number.POSITIVE_INFINITY;
+  const railsExpiry = typeof value.gitlab_rails?.token_expires_at === "string" ? Date.parse(value.gitlab_rails.token_expires_at) : Number.POSITIVE_INFINITY;
+  const expiry = Math.min(workflowExpiry, railsExpiry);
+  if (!Number.isFinite(expiry)) return Date.now() + 5 * 60 * 1e3;
+  return Math.max(Date.now() + 1e3, expiry - WORKFLOW_TOKEN_EXPIRY_BUFFER_MS);
+}
+
+// src/workflow/types.ts
+var WORKFLOW_STATUS = {
+  CREATED: "CREATED",
+  RUNNING: "RUNNING",
+  FINISHED: "FINISHED",
+  FAILED: "FAILED",
+  STOPPED: "STOPPED",
+  INPUT_REQUIRED: "INPUT_REQUIRED",
+  PLAN_APPROVAL_REQUIRED: "PLAN_APPROVAL_REQUIRED",
+  TOOL_CALL_APPROVAL_REQUIRED: "TOOL_CALL_APPROVAL_REQUIRED"
+};
+
+// src/workflow/websocket-client.ts
+import WebSocket from "isomorphic-ws";
+var WorkflowWebSocketClient = class {
+  #socket = null;
+  #heartbeat;
+  #keepalive;
+  #callbacks;
+  constructor(callbacks) {
+    this.#callbacks = callbacks;
+  }
+  async connect(url, headers) {
+    const socket = new WebSocket(url, { headers });
+    this.#socket = socket;
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        socket.close(1e3);
+        reject(new Error(`WebSocket connection timeout after ${WORKFLOW_CONNECT_TIMEOUT_MS}ms`));
+      }, WORKFLOW_CONNECT_TIMEOUT_MS);
+      const cleanup = () => {
+        clearTimeout(timeout);
+        socket.off("open", onOpen);
+        socket.off("error", onError);
+      };
+      const onOpen = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(error);
+      };
+      socket.once("open", onOpen);
+      socket.once("error", onError);
+    });
+    socket.on("message", (data) => {
+      try {
+        const payload = decodeSocketMessage(data);
+        if (!payload) return;
+        const parsed = JSON.parse(payload);
+        this.#callbacks.action(parsed);
+      } catch (error) {
+        const next = error instanceof Error ? error : new Error(String(error));
+        this.#callbacks.error(next);
+      }
+    });
+    socket.on("error", (error) => {
+      this.#callbacks.error(error instanceof Error ? error : new Error(String(error)));
+    });
+    socket.on("close", (code, reason) => {
+      this.#stopIntervals();
+      this.#callbacks.close(code, reason?.toString("utf8") ?? "");
+    });
+    this.#heartbeat = setInterval(() => {
+      this.send({ heartbeat: { timestamp: Date.now() } });
+    }, WORKFLOW_HEARTBEAT_INTERVAL_MS);
+    this.#keepalive = setInterval(() => {
+      if (!this.#socket || this.#socket.readyState !== WebSocket.OPEN) return;
+      this.#socket.ping(Buffer.from(String(Date.now())));
+    }, WORKFLOW_KEEPALIVE_INTERVAL_MS);
+  }
+  send(event) {
+    if (!this.#socket || this.#socket.readyState !== WebSocket.OPEN) return false;
+    this.#socket.send(JSON.stringify(event));
+    return true;
+  }
+  close() {
+    this.#stopIntervals();
+    if (!this.#socket) return;
+    this.#socket.close(1e3);
+    this.#socket = null;
+  }
+  #stopIntervals() {
+    if (this.#heartbeat) {
+      clearInterval(this.#heartbeat);
+      this.#heartbeat = void 0;
+    }
+    if (this.#keepalive) {
+      clearInterval(this.#keepalive);
+      this.#keepalive = void 0;
+    }
+  }
+};
+function decodeSocketMessage(data) {
+  if (typeof data === "string") return data;
+  if (Buffer.isBuffer(data)) return data.toString("utf8");
+  if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
+  if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+  return void 0;
+}
+
+// src/workflow/session.ts
+var WorkflowSession = class {
+  #client;
+  #tokenService;
+  #modelId;
+  #workflowId;
+  #projectPath;
+  #rootNamespaceId;
+  #checkpoint = createCheckpointState();
+  #running = false;
+  constructor(client, modelId) {
+    this.#client = client;
+    this.#tokenService = new WorkflowTokenService(client);
+    this.#modelId = modelId;
+  }
+  get workflowId() {
+    return this.#workflowId;
+  }
+  reset() {
+    this.#workflowId = void 0;
+    this.#checkpoint = createCheckpointState();
+    this.#tokenService.clear();
+  }
+  async *runTurn(goal, abortSignal) {
+    if (this.#running) {
+      throw new Error("workflow session is already running");
+    }
+    this.#running = true;
+    const queue = new AsyncQueue();
+    const socket = new WorkflowWebSocketClient({
+      action: (action) => queue.push({ type: "action", action }),
+      error: (error) => queue.push({ type: "error", error }),
+      close: (code, reason) => queue.push({ type: "close", code, reason })
+    });
+    const onAbort = () => {
+      socket.send({
+        stopWorkflow: {
+          reason: "ABORTED"
+        }
+      });
+      socket.close();
+    };
+    try {
+      if (abortSignal?.aborted) throw new Error("aborted");
+      if (!this.#workflowId) this.#workflowId = await this.#createWorkflow(goal);
+      const access = await this.#tokenService.get(this.#rootNamespaceId);
+      const url = buildWebSocketUrl(this.#client.instanceUrl, this.#modelId);
+      await socket.connect(url, {
+        authorization: `Bearer ${this.#client.token}`,
+        origin: new URL(this.#client.instanceUrl).origin,
+        "x-request-id": randomUUID(),
+        "x-gitlab-client-type": "node-websocket"
+      });
+      abortSignal?.addEventListener("abort", onAbort, { once: true });
+      const sent = socket.send({
+        startRequest: {
+          workflowID: this.#workflowId,
+          clientVersion: WORKFLOW_CLIENT_VERSION,
+          workflowDefinition: WORKFLOW_DEFINITION,
+          goal,
+          workflowMetadata: JSON.stringify({
+            extended_logging: access?.workflow_metadata?.extended_logging ?? false
+          }),
+          clientCapabilities: [],
+          mcpTools: [],
+          additional_context: [],
+          preapproved_tools: []
+        }
+      });
+      if (!sent) throw new Error("failed to send workflow startRequest");
+      for (; ; ) {
+        const event = await queue.shift();
+        if (event.type === "error") throw event.error;
+        if (event.type === "close") {
+          if (event.code === 1e3 || event.code === 1006) return;
+          throw new Error(`workflow websocket closed abnormally (${event.code}): ${event.reason}`);
+        }
+        if (isCheckpointAction(event.action)) {
+          const deltas = extractAgentTextDeltas(event.action.newCheckpoint.checkpoint, this.#checkpoint);
+          for (const delta of deltas) {
+            yield {
+              type: "text-delta",
+              value: delta
+            };
+          }
+          if (isTurnComplete(event.action.newCheckpoint.status)) {
+            socket.close();
+          }
+          continue;
+        }
+        if (!event.action.requestID) continue;
+        socket.send({
+          actionResponse: {
+            requestID: event.action.requestID,
+            plainTextResponse: {
+              response: "",
+              error: WORKFLOW_TOOL_ERROR_MESSAGE
+            }
+          }
+        });
+      }
+    } finally {
+      this.#running = false;
+      abortSignal?.removeEventListener("abort", onAbort);
+      socket.close();
+    }
+  }
+  async #createWorkflow(goal) {
+    await this.#loadProjectContext();
+    const body = {
+      goal,
+      workflow_definition: WORKFLOW_DEFINITION,
+      environment: WORKFLOW_ENVIRONMENT,
+      allow_agent_to_request_user: true,
+      ...this.#projectPath ? {
+        project_id: this.#projectPath
+      } : {}
+    };
+    const created = await post(this.#client, "ai/duo_workflows/workflows", body);
+    if (created.id === void 0 || created.id === null) {
+      const details = [created.message, created.error].filter(Boolean).join("; ");
+      throw new Error(`failed to create workflow${details ? `: ${details}` : ""}`);
+    }
+    return String(created.id);
+  }
+  async #loadProjectContext() {
+    if (this.#projectPath !== void 0) return;
+    const projectPath = await detectProjectPath(process.cwd(), this.#client.instanceUrl);
+    this.#projectPath = projectPath;
+    if (!projectPath) return;
+    try {
+      const project = await fetchProjectDetails(this.#client, projectPath);
+      this.#rootNamespaceId = await resolveRootNamespaceId(this.#client, project.namespaceId);
+    } catch {
+      this.#rootNamespaceId = void 0;
+    }
+  }
+};
+function isCheckpointAction(action) {
+  return Boolean(action.newCheckpoint);
+}
+function isTurnComplete(status) {
+  return status === WORKFLOW_STATUS.INPUT_REQUIRED || status === WORKFLOW_STATUS.FINISHED || status === WORKFLOW_STATUS.FAILED || status === WORKFLOW_STATUS.STOPPED || status === WORKFLOW_STATUS.PLAN_APPROVAL_REQUIRED || status === WORKFLOW_STATUS.TOOL_CALL_APPROVAL_REQUIRED;
+}
+function buildWebSocketUrl(instanceUrl, modelId) {
+  const base = new URL(instanceUrl.endsWith("/") ? instanceUrl : `${instanceUrl}/`);
+  const url = new URL("api/v4/ai/duo_workflows/ws", base);
+  if (base.protocol === "https:") url.protocol = "wss:";
+  if (base.protocol === "http:") url.protocol = "ws:";
+  if (modelId) url.searchParams.set("user_selected_model_identifier", modelId);
+  return url.toString();
+}
+var AsyncQueue = class {
+  #values = [];
+  #waiters = [];
+  push(value) {
+    const waiter = this.#waiters.shift();
+    if (waiter) {
+      waiter(value);
+      return;
+    }
+    this.#values.push(value);
+  }
+  shift() {
+    const value = this.#values.shift();
+    if (value !== void 0) return Promise.resolve(value);
+    return new Promise((resolve) => this.#waiters.push(resolve));
+  }
+};
+
+// src/provider/duo-workflow-model.ts
+var sessions = /* @__PURE__ */ new Map();
+var DuoWorkflowModel = class {
+  specificationVersion = "v2";
+  provider = PROVIDER_ID;
+  modelId;
+  supportedUrls = {};
+  #client;
+  constructor(modelId, client) {
+    this.modelId = modelId;
+    this.#client = client;
+  }
+  async doGenerate(options) {
+    const goal = extractGoal(options.prompt);
+    if (!goal) throw new Error("missing user message content");
+    const session = this.#resolveSession(options);
+    const chunks = [];
+    for await (const item of session.runTurn(goal, options.abortSignal)) {
+      if (item.type === "text-delta") chunks.push(item.value);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: chunks.join("")
+        }
+      ],
+      finishReason: "stop",
+      usage: {
+        inputTokens: void 0,
+        outputTokens: void 0,
+        totalTokens: void 0
+      },
+      warnings: []
+    };
+  }
+  async doStream(options) {
+    const goal = extractGoal(options.prompt);
+    if (!goal) throw new Error("missing user message content");
+    const session = this.#resolveSession(options);
+    const textId = randomUUID2();
+    return {
+      stream: new ReadableStream({
+        start: async (controller) => {
+          controller.enqueue({
+            type: "stream-start",
+            warnings: []
+          });
+          let hasText = false;
+          try {
+            for await (const item of session.runTurn(goal, options.abortSignal)) {
+              if (item.type !== "text-delta") continue;
+              if (!item.value) continue;
+              if (!hasText) {
+                hasText = true;
+                controller.enqueue({
+                  type: "text-start",
+                  id: textId
+                });
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: textId,
+                delta: item.value
+              });
+            }
+            if (hasText) {
+              controller.enqueue({
+                type: "text-end",
+                id: textId
+              });
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason: "stop",
+              usage: {
+                inputTokens: void 0,
+                outputTokens: void 0,
+                totalTokens: void 0
+              }
+            });
+            controller.close();
+          } catch (error) {
+            controller.enqueue({
+              type: "error",
+              error
+            });
+            controller.enqueue({
+              type: "finish",
+              finishReason: "error",
+              usage: {
+                inputTokens: void 0,
+                outputTokens: void 0,
+                totalTokens: void 0
+              }
+            });
+            controller.close();
+          }
+        }
+      }),
+      request: {
+        body: {
+          goal,
+          workflowID: session.workflowId
+        }
+      }
+    };
+  }
+  #resolveSession(options) {
+    const sessionID = readSessionID(options);
+    const key = `${this.#client.instanceUrl}::${this.modelId}::${sessionID}`;
+    const existing = sessions.get(key);
+    if (existing) return existing;
+    const created = new WorkflowSession(this.#client, this.modelId);
+    sessions.set(key, created);
+    return created;
+  }
+};
+function extractGoal(prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const message = prompt[i];
+    if (message.role !== "user") continue;
+    const content = Array.isArray(message.content) ? message.content : [];
+    const text2 = content.filter((part) => part.type === "text").map((part) => part.text).join("\n").trim();
+    if (text2) return text2;
+  }
+  return "";
+}
+function readSessionID(options) {
+  const providerBlock = readProviderBlock(options);
+  if (typeof providerBlock?.workflowSessionID === "string" && providerBlock.workflowSessionID.trim()) {
+    return providerBlock.workflowSessionID.trim();
+  }
+  const headers = options.headers ?? {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === "x-opencode-session" && value?.trim()) return value.trim();
+  }
+  return "default";
+}
+function readProviderBlock(options) {
+  const block = options.providerOptions?.[PROVIDER_ID];
+  if (block && typeof block === "object" && !Array.isArray(block)) {
+    return block;
+  }
+  if (!options.providerOptions) return void 0;
+  for (const value of Object.values(options.providerOptions)) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// src/provider/index.ts
+function createFallbackProvider(input = {}) {
+  const instanceUrl = normalizeInstanceUrl(input.instanceUrl ?? envInstanceUrl());
+  const token = text(input.apiKey) ?? text(input.token) ?? process.env.GITLAB_TOKEN ?? process.env.GITLAB_OAUTH_TOKEN ?? "";
+  const client = { instanceUrl, token };
   return {
     languageModel(modelId) {
-      return placeholderModel(modelId);
+      return new DuoWorkflowModel(modelId, client);
+    },
+    agenticChat(modelId, _options) {
+      return new DuoWorkflowModel(modelId, client);
     },
     textEmbeddingModel(modelId) {
       throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
@@ -342,7 +898,7 @@ var entry = (input) => {
   if (isPluginInput(input)) {
     return createPluginHooks(input);
   }
-  return createFallbackProvider();
+  return createFallbackProvider(input);
 };
 var createGitLabDuoAgentic = entry;
 var GitLabDuoAgenticPlugin = entry;

package/package.json

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