opencode-gitlab-duo-agentic 0.1.14 → 0.1.16

package/dist/index.js

@@ -1,8 +1,270 @@
 // src/constants.ts
 var PROVIDER_ID = "gitlab";
-var MODEL_ID = "duo-agentic";
+var DEFAULT_MODEL_ID = "duo-chat-sonnet-4-5";
 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.";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+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";
+import fs2 from "fs/promises";
+import os from "os";
+import path2 from "path";
+
+// src/gitlab/client.ts
+var GitLabApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "GitLabApiError";
+  }
+};
+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, {
+    ...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, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${options.token}`
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!response.ok) {
+    const text2 = await response.text().catch(() => "");
+    throw new GitLabApiError(response.status, `GraphQL request failed (${response.status}): ${text2}`);
+  }
+  const result = await response.json();
+  if (result.errors?.length) {
+    throw new GitLabApiError(0, result.errors.map((e) => e.message).join("; "));
+  }
+  if (!result.data) {
+    throw new GitLabApiError(0, "GraphQL response missing data");
+  }
+  return result.data;
+}
+
+// src/gitlab/project.ts
+import fs from "fs/promises";
+import path from "path";
+async function detectProjectPath(cwd, instanceUrl) {
+  const instance = new URL(instanceUrl);
+  const instanceHost = instance.host;
+  const instanceBasePath = instance.pathname.replace(/\/$/, "");
+  let current = cwd;
+  for (; ; ) {
+    try {
+      const config = await readGitConfig(current);
+      const url = extractOriginUrl(config);
+      if (!url) return void 0;
+      const remote = parseRemoteUrl(url);
+      if (!remote || remote.host !== instanceHost) return void 0;
+      return normalizeProjectPath(remote.path, instanceBasePath);
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) return void 0;
+      current = parent;
+    }
+  }
+}
+async function fetchProjectDetails(client, projectPath) {
+  const encoded = encodeURIComponent(projectPath);
+  const data = await get(client, `projects/${encoded}`);
+  if (!data.id || !data.namespace?.id) {
+    throw new Error(`Project ${projectPath}: missing id or namespace`);
+  }
+  return {
+    projectId: String(data.id),
+    namespaceId: String(data.namespace.id)
+  };
+}
+async function resolveRootNamespaceId(client, namespaceId) {
+  let currentId = namespaceId;
+  for (let depth = 0; depth < 20; depth++) {
+    let ns;
+    try {
+      ns = await get(client, `namespaces/${currentId}`);
+    } catch {
+      break;
+    }
+    if (!ns.parent_id) {
+      currentId = String(ns.id ?? currentId);
+      break;
+    }
+    currentId = String(ns.parent_id);
+  }
+  return `gid://gitlab/Group/${currentId}`;
+}
+async function readGitConfig(cwd) {
+  const gitPath = path.join(cwd, ".git");
+  const stat = await fs.stat(gitPath);
+  if (stat.isDirectory()) {
+    return fs.readFile(path.join(gitPath, "config"), "utf8");
+  }
+  const content = await fs.readFile(gitPath, "utf8");
+  const match = /^gitdir:\s*(.+)$/m.exec(content);
+  if (!match) throw new Error("Invalid .git file");
+  const gitdir = match[1].trim();
+  const resolved = path.isAbsolute(gitdir) ? gitdir : path.join(cwd, gitdir);
+  return fs.readFile(path.join(resolved, "config"), "utf8");
+}
+function extractOriginUrl(config) {
+  const lines = config.split("\n");
+  let inOrigin = false;
+  let originUrl;
+  let firstUrl;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const section = /^\[remote\s+"([^"]+)"\]$/.exec(trimmed);
+    if (section) {
+      inOrigin = section[1] === "origin";
+      continue;
+    }
+    const urlMatch = /^url\s*=\s*(.+)$/.exec(trimmed);
+    if (urlMatch) {
+      const value = urlMatch[1].trim();
+      if (!firstUrl) firstUrl = value;
+      if (inOrigin) originUrl = value;
+    }
+  }
+  return originUrl ?? firstUrl;
+}
+function parseRemoteUrl(url) {
+  if (url.startsWith("git@")) {
+    const match = /^git@([^:]+):(.+)$/.exec(url);
+    return match ? { host: match[1], path: match[2] } : void 0;
+  }
+  try {
+    const parsed = new URL(url);
+    return { host: parsed.host, path: parsed.pathname.replace(/^\//, "") };
+  } catch {
+    return void 0;
+  }
+}
+function normalizeProjectPath(remotePath, instanceBasePath) {
+  let p = remotePath;
+  if (instanceBasePath && instanceBasePath !== "/") {
+    const base = instanceBasePath.replace(/^\//, "") + "/";
+    if (p.startsWith(base)) p = p.slice(base.length);
+  }
+  if (p.endsWith(".git")) p = p.slice(0, -4);
+  return p.length > 0 ? p : void 0;
+}
+
+// src/gitlab/models.ts
+var QUERY = `query lsp_aiChatAvailableModels($rootNamespaceId: GroupID!) {
+  aiChatAvailableModels(rootNamespaceId: $rootNamespaceId) {
+    defaultModel { name ref }
+    selectableModels { name ref }
+    pinnedModel { name ref }
+  }
+}`;
+async function loadAvailableModels(instanceUrl, token, cwd) {
+  const cachePath = getCachePath(instanceUrl, cwd);
+  const cached = await readCache(cachePath);
+  if (cached && !isStale(cached)) {
+    return cached.models;
+  }
+  if (token) {
+    try {
+      const models = await fetchModelsFromApi({ instanceUrl, token }, cwd);
+      if (models.length > 0) {
+        await writeCache(cachePath, { cachedAt: (/* @__PURE__ */ new Date()).toISOString(), instanceUrl, models });
+        return models;
+      }
+    } catch {
+    }
+  }
+  if (cached) {
+    return cached.models;
+  }
+  return [{ id: DEFAULT_MODEL_ID, name: DEFAULT_MODEL_ID }];
+}
+async function fetchModelsFromApi(client, cwd) {
+  const projectPath = await detectProjectPath(cwd, client.instanceUrl);
+  if (!projectPath) return [];
+  const project = await fetchProjectDetails(client, projectPath);
+  const rootNamespaceId = await resolveRootNamespaceId(client, project.namespaceId);
+  const data = await graphql(client, QUERY, { rootNamespaceId });
+  const available = data.aiChatAvailableModels;
+  if (!available) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const models = [];
+  function add(entry2) {
+    if (!entry2?.ref || seen.has(entry2.ref)) return;
+    seen.add(entry2.ref);
+    models.push({ id: entry2.ref, name: entry2.name || entry2.ref });
+  }
+  add(available.defaultModel);
+  add(available.pinnedModel);
+  for (const m of available.selectableModels ?? []) add(m);
+  return models;
+}
+function getCachePath(instanceUrl, cwd) {
+  const key = `${instanceUrl}::${cwd}`;
+  const hash = crypto.createHash("sha256").update(key).digest("hex").slice(0, 12);
+  const dir = process.env.XDG_CACHE_HOME?.trim() ? path2.join(process.env.XDG_CACHE_HOME, "opencode") : path2.join(os.homedir(), ".cache", "opencode");
+  return path2.join(dir, `gitlab-duo-models-${hash}.json`);
+}
+function isStale(payload) {
+  const age = Date.now() - Date.parse(payload.cachedAt);
+  return age > CACHE_TTL_MS;
+}
+async function readCache(cachePath) {
+  try {
+    const raw = await fs2.readFile(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.models?.length) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(cachePath, payload) {
+  try {
+    await fs2.mkdir(path2.dirname(cachePath), { recursive: true });
+    await fs2.writeFile(cachePath, JSON.stringify(payload, null, 2), "utf8");
+  } catch {
+  }
+}
 
 // src/utils/url.ts
 function text(value) {
@@ -25,65 +287,595 @@ function normalizeInstanceUrl(value) {
 }
 
 // src/plugin/config.ts
-function applyRuntimeConfig(config) {
+async function applyRuntimeConfig(config, directory) {
   config.provider ??= {};
   const current = config.provider[PROVIDER_ID] ?? {};
   const options = current.options ?? {};
-  const models = current.models ?? {};
   const instanceUrl = normalizeInstanceUrl(options.instanceUrl ?? envInstanceUrl());
+  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,
-    whitelist: [MODEL_ID],
+    whitelist: modelIds,
     options: {
       ...options,
       instanceUrl
     },
     models: {
-      ...models,
-      [MODEL_ID]: {
-        id: MODEL_ID,
-        name: "GitLab Duo Agentic"
-      }
+      ...current.models ?? {},
+      ...models
     }
   };
 }
+function toModelsConfig(available) {
+  const out = {};
+  for (const m of available) {
+    out[m.id] = { id: m.id, name: m.name };
+  }
+  return out;
+}
 
 // src/plugin/hooks.ts
-async function createPluginHooks(_input) {
+async function createPluginHooks(input) {
   return {
-    config: async (config) => applyRuntimeConfig(config)
+    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 fallbackModel(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 ?? "";
   return {
     languageModel(modelId) {
-      if (modelId !== MODEL_ID) {
-        throw new NoSuchModelError({ modelId, modelType: "languageModel" });
-      }
-      return fallbackModel(modelId);
+      return new DuoWorkflowModel(modelId, {
+        instanceUrl,
+        token
+      });
     },
     textEmbeddingModel(modelId) {
       throw new NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
@@ -104,7 +896,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.14",
+  "version": "0.1.16",
   "description": "OpenCode plugin and provider for GitLab Duo Agentic workflows",
   "license": "MIT",
   "type": "module",