opencode-gitlab-duo-agentic 0.1.2 → 0.1.3

package/README.md

@@ -1,10 +1,16 @@
 # opencode-gitlab-duo-agentic
 
-OpenCode plugin and provider for GitLab Duo Agentic workflows, published as a single npm package.
+OpenCode plugin for GitLab Duo Agentic. It registers the provider, discovers models from the GitLab API, and exposes file-reading tools.
 
-## Install
+## Setup
 
-Add the plugin to your OpenCode config:
+1. Export your GitLab token:
+
+```bash
+export GITLAB_TOKEN=glpat-...
+```
+
+2. Add the plugin to `opencode.json`:
 
 ```json
 {
@@ -13,40 +19,40 @@ Add the plugin to your OpenCode config:
 }
 ```
 
-The plugin registers the provider `gitlab-duo-agentic` automatically and resolves it from the same module entrypoint as the plugin.
+3. Run `opencode`. The provider, models, and tools are registered automatically.
 
-## Required environment variables
+`GITLAB_INSTANCE_URL` defaults to `https://gitlab.com`. Set it only for self-managed GitLab.
 
-```bash
-export GITLAB_TOKEN=glpat-...
-export GITLAB_INSTANCE_URL=https://gitlab.com
-```
-
-`GITLAB_INSTANCE_URL` is optional and defaults to `https://gitlab.com`.
+## Provider options
 
-## Optional model configuration
+Override defaults in `opencode.json` under `provider.gitlab-duo-agentic.options`.
 
-The plugin discovers models in this order:
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `instanceUrl` | string | `GITLAB_INSTANCE_URL` or `https://gitlab.com` | GitLab instance URL |
+| `apiKey` | string | `GITLAB_TOKEN` | Personal access token |
+| `sendSystemContext` | boolean | `true` | Send system context to Duo |
+| `enableMcp` | boolean | `true` | Enable MCP tools |
+| `systemRules` | string | `""` | Inline system rules |
+| `systemRulesPath` | string | `""` | Path to a system rules file |
 
-1. Live GitLab API discovery with cache (TTL default: `86400` seconds)
-2. `models.json` file resolution:
-   - `options.modelsPath` in provider config
-   - `GITLAB_DUO_MODELS_PATH`
-   - `models.json` found by walking upward from `process.cwd()`
-3. Fallback default model `duo-agentic`
+## Model discovery
 
-Cache settings:
+Models are discovered in this order:
 
-- Location: `~/.cache/opencode/gitlab-duo-models-*.json`
-- TTL override: `GITLAB_DUO_MODELS_CACHE_TTL` (seconds)
+1. Local cache (TTL: 24h)
+2. Live fetch from GitLab GraphQL API
+3. Stale cache (if live fetch fails)
+4. `models.json` on disk
+5. Default `duo-agentic` model
 
-You can still generate a local `models.json` manually using `src/scripts/fetch_models.ts`.
+Cache is stored in `~/.cache/opencode/` (or `XDG_CACHE_HOME`). Override TTL with `GITLAB_DUO_MODELS_CACHE_TTL` (seconds).
 
 ## Development
 
 ```bash
 npm install
-npm run typecheck
 npm run build
+npm run typecheck
 npm run pack:check
 ```

package/dist/index.js

@@ -1225,6 +1225,14 @@ var GitLabDuoAgenticLanguageModel = class {
     const workflowType = "chat";
     const promptText = extractLastUserText(options.prompt);
     const toolResults = extractToolResults(options.prompt);
+    console.warn("[duo-debug] doStream called", {
+      promptText: promptText?.slice(0, 80),
+      toolResultCount: toolResults.length,
+      hasStarted: this.#runtime.hasStarted,
+      lastSentPrompt: this.#lastSentPrompt?.slice(0, 80) ?? null,
+      pendingToolRequests: this.#pendingToolRequests.size,
+      sentToolCallIds: this.#sentToolCallIds.size
+    });
     this.#runtime.resetMapperState();
     if (!this.#runtime.hasStarted) {
       this.#sentToolCallIds.clear();
@@ -1234,14 +1242,18 @@ var GitLabDuoAgenticLanguageModel = class {
         }
       }
       this.#lastSentPrompt = null;
+      console.warn("[duo-debug] hasStarted=false => reset sentToolCallIds, lastSentPrompt=null");
     }
     const freshToolResults = toolResults.filter((r) => !this.#sentToolCallIds.has(r.toolCallId));
+    console.warn("[duo-debug] freshToolResults:", freshToolResults.length);
     const modelRef = this.modelId === GITLAB_DUO_DEFAULT_MODEL_ID ? void 0 : this.modelId;
     this.#runtime.setSelectedModelIdentifier(modelRef);
     await this.#runtime.ensureConnected(promptText || "", workflowType);
+    console.warn("[duo-debug] ensureConnected returned OK");
     const mcpTools = this.#options.enableMcp === false ? [] : buildMcpTools(options);
     const toolContext = buildToolContext(mcpTools);
     const isNewUserMessage = promptText != null && promptText !== this.#lastSentPrompt;
+    console.warn("[duo-debug] isNewUserMessage:", isNewUserMessage, "promptText != null:", promptText != null, "promptText !== lastSentPrompt:", promptText !== this.#lastSentPrompt);
     let sentToolResults = false;
     if (freshToolResults.length > 0) {
       for (const result of freshToolResults) {
@@ -1288,6 +1300,7 @@ var GitLabDuoAgenticLanguageModel = class {
         this.#pendingToolRequests.delete(result.toolCallId);
       }
     }
+    console.warn("[duo-debug] startRequest gate: !sentToolResults:", !sentToolResults, "isNewUserMessage:", isNewUserMessage, "=> will send:", !sentToolResults && isNewUserMessage);
     if (!sentToolResults && isNewUserMessage) {
       const extraContext = [];
       if (toolContext) extraContext.push(toolContext);
@@ -1349,6 +1362,7 @@ var GitLabDuoAgenticLanguageModel = class {
           }
         });
       }
+      console.warn("[duo-debug] >>> calling sendStartRequest", { goal: promptText?.slice(0, 80), hasStarted: this.#runtime.hasStarted, extraContextCount: extraContext.length });
       this.#runtime.sendStartRequest(
         promptText,
         workflowType,
@@ -1357,11 +1371,15 @@ var GitLabDuoAgenticLanguageModel = class {
         extraContext
       );
       this.#lastSentPrompt = promptText;
+      console.warn("[duo-debug] >>> sendStartRequest completed, lastSentPrompt set");
       this.#usageEstimator.addInputChars(promptText);
       for (const ctx of extraContext) {
         if (ctx.content) this.#usageEstimator.addInputChars(ctx.content);
       }
+    } else {
+      console.warn("[duo-debug] SKIPPED sendStartRequest (sentToolResults:", sentToolResults, "isNewUserMessage:", isNewUserMessage, ")");
     }
+    console.warn("[duo-debug] creating event stream iterator");
     const iterator = this.#mapEventsToStream(this.#runtime.getEventStream());
     const stream = asyncIteratorToReadableStream(iterator);
     return {
@@ -1374,9 +1392,13 @@ var GitLabDuoAgenticLanguageModel = class {
   async *#mapEventsToStream(events) {
     const state = { textStarted: false };
     const estimator = this.#usageEstimator;
+    let eventCount = 0;
+    console.warn("[duo-debug] #mapEventsToStream: starting iteration");
     yield { type: "stream-start", warnings: [] };
     try {
       for await (const event of events) {
+        eventCount++;
+        console.warn("[duo-debug] #mapEventsToStream event #" + eventCount + ":", event.type, event.type === "TEXT_CHUNK" ? "(len=" + event.content.length + ")" : "");
         if (event.type === "TEXT_CHUNK") {
           if (event.content.length > 0) {
             estimator.addOutputChars(event.content);
@@ -1422,9 +1444,11 @@ var GitLabDuoAgenticLanguageModel = class {
         }
       }
     } catch (streamErr) {
+      console.warn("[duo-debug] #mapEventsToStream: caught error after", eventCount, "events:", streamErr instanceof Error ? streamErr.message : String(streamErr));
       yield { type: "error", error: streamErr instanceof Error ? streamErr : new Error(String(streamErr)) };
       return;
     }
+    console.warn("[duo-debug] #mapEventsToStream: loop ended normally after", eventCount, "events => yielding finish:stop");
     yield { type: "finish", finishReason: "stop", usage: this.#currentUsage };
   }
   // ---------------------------------------------------------------------------
@@ -1871,14 +1895,26 @@ var GitLabAgenticRuntime = class {
   // Connection lifecycle
   // ---------------------------------------------------------------------------
   async ensureConnected(goal, workflowType) {
+    console.warn("[duo-debug] ensureConnected called", {
+      hasStream: !!this.#stream,
+      hasWorkflowId: !!this.#workflowId,
+      workflowId: this.#workflowId?.slice(0, 12),
+      hasQueue: !!this.#queue,
+      startRequestSent: this.#startRequestSent
+    });
     if (this.#stream && this.#workflowId && this.#queue) {
+      console.warn("[duo-debug] ensureConnected: short-circuit (already connected)");
       return;
     }
     if (!this.#containerParams) {
       this.#containerParams = await this.#resolveContainerParams();
     }
     if (!this.#workflowId) {
+      console.warn("[duo-debug] ensureConnected: creating new workflow");
       this.#workflowId = await this.#createWorkflow(goal, workflowType);
+      console.warn("[duo-debug] ensureConnected: workflow created:", this.#workflowId?.slice(0, 12));
+    } else {
+      console.warn("[duo-debug] ensureConnected: reusing existing workflowId:", this.#workflowId?.slice(0, 12));
     }
     const token = await this.#dependencies.workflowService.getWorkflowToken(
       this.#options.instanceUrl,
@@ -1886,15 +1922,19 @@ var GitLabAgenticRuntime = class {
       workflowType
     );
     this.#workflowToken = token;
+    console.warn("[duo-debug] ensureConnected: got workflow token");
     const MAX_LOCK_RETRIES = 3;
     const LOCK_RETRY_DELAY_MS = 3e3;
     for (let attempt = 1; attempt <= MAX_LOCK_RETRIES; attempt++) {
       this.#queue = new AsyncQueue();
       try {
+        console.warn("[duo-debug] ensureConnected: connecting WebSocket (attempt", attempt, ")");
         await this.#connectWebSocket();
+        console.warn("[duo-debug] ensureConnected: WebSocket connected OK");
         return;
       } catch (err2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
+        console.warn("[duo-debug] ensureConnected: WebSocket error:", msg);
         if ((msg.includes("1013") || msg.includes("lock")) && attempt < MAX_LOCK_RETRIES) {
           this.#resetStreamState();
           await this.#dependencies.clock.sleep(LOCK_RETRY_DELAY_MS);
@@ -1939,7 +1979,13 @@ var GitLabAgenticRuntime = class {
         preapproved_tools: preapprovedTools
       }
     };
-    this.#stream.write(startRequest);
+    console.warn("[duo-debug] sendStartRequest: writing to stream", {
+      workflowId: this.#workflowId?.slice(0, 12),
+      goal: goal?.slice(0, 80),
+      contextCount: additionalContext.length
+    });
+    const writeResult = this.#stream.write(startRequest);
+    console.warn("[duo-debug] sendStartRequest: write() returned:", writeResult);
     this.#startRequestSent = true;
   }
   sendToolResponse(requestId, response, responseType) {
@@ -2028,12 +2074,14 @@ var GitLabAgenticRuntime = class {
   #bindStream(stream, queue) {
     const now = () => this.#dependencies.clock.now();
     const closeWithError = (message) => {
+      console.warn("[duo-debug] stream closeWithError:", message);
       queue.push({ type: "ERROR", message, timestamp: now() });
       queue.close();
       this.#resetStreamState();
     };
     const handleAction = async (action) => {
       if (action.newCheckpoint) {
+        console.warn("[duo-debug] stream data: newCheckpoint status=", action.newCheckpoint.status, "goal=", action.newCheckpoint.goal?.slice(0, 40));
         const duoEvent = {
           checkpoint: action.newCheckpoint.checkpoint,
           errors: action.newCheckpoint.errors || [],
@@ -2041,6 +2089,7 @@ var GitLabAgenticRuntime = class {
           workflowStatus: action.newCheckpoint.status
         };
         const events = await this.#mapper.mapWorkflowEvent(duoEvent);
+        console.warn("[duo-debug] mapper produced", events.length, "events:", events.map((e) => e.type));
         for (const event of events) {
           queue.push(event);
         }
@@ -2048,6 +2097,7 @@ var GitLabAgenticRuntime = class {
       }
       const toolRequest = mapWorkflowActionToToolRequest(action);
       if (toolRequest) {
+        console.warn("[duo-debug] stream data: toolRequest", toolRequest.toolName);
         queue.push({
           type: "TOOL_REQUEST",
           ...toolRequest,
@@ -2055,6 +2105,7 @@ var GitLabAgenticRuntime = class {
         });
         return;
       }
+      console.warn("[duo-debug] stream data: unhandled action", Object.keys(action));
     };
     stream.on("data", (action) => {
       void handleAction(action).catch((error) => {
@@ -2063,9 +2114,11 @@ var GitLabAgenticRuntime = class {
       });
     });
     stream.on("error", (err2) => {
+      console.warn("[duo-debug] stream error:", err2.message);
       closeWithError(err2.message);
     });
     stream.on("end", () => {
+      console.warn("[duo-debug] stream end => closing queue + resetStreamState");
       queue.close();
       this.#resetStreamState();
     });
@@ -2087,6 +2140,7 @@ var GitLabAgenticRuntime = class {
     this.#bindStream(stream, this.#queue);
   }
   #resetStreamState() {
+    console.warn("[duo-debug] #resetStreamState called", { hadStream: !!this.#stream, hadQueue: !!this.#queue, workflowId: this.#workflowId?.slice(0, 12) });
     this.#stream = void 0;
     this.#queue = void 0;
     this.#startRequestSent = false;

package/package.json

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