@automatalabs/acp-agents 0.15.0 → 0.17.0

package/dist/runner.js

@@ -98,6 +98,137 @@ export class AcpAgentRunner {
     async openSession(opts) {
         return this.createInteractiveSession(opts, "openSession", (connection, prepared) => connection.openSession(prepared.sessionOptions));
     }
+    /** Return the selected backend's initialize-advertised authentication methods. */
+    async authMethods(opts = {}) {
+        if (this.disposed)
+            throw new Error("ACP agent runner is disposed");
+        const backend = selectBackend(opts, this.backends);
+        const connection = this.createDedicatedConnection(backend, () => undefined);
+        try {
+            if (this.disposed)
+                throw new Error("ACP agent runner is disposed");
+            return await connection.authMethods();
+        }
+        finally {
+            await disposeBestEffort(connection);
+        }
+    }
+    /** Drive ACP authenticate on the selected backend. */
+    async authenticate(opts) {
+        if (this.disposed)
+            throw new Error("ACP agent runner is disposed");
+        validateRequiredString(opts.methodId, opts.label, "authenticate", "methodId");
+        opts.signal?.throwIfAborted();
+        const backend = selectBackend(opts, this.backends);
+        const connection = this.createDedicatedConnection(backend, () => undefined);
+        try {
+            const request = {
+                methodId: opts.methodId,
+                ...(opts.meta ? { _meta: opts.meta } : {}),
+            };
+            const response = await connection.authenticate(request, opts.label);
+            opts.signal?.throwIfAborted();
+            if (this.disposed)
+                throw new Error("ACP agent runner is disposed");
+            return response;
+        }
+        finally {
+            await disposeBestEffort(connection);
+        }
+    }
+    /** List configurable providers from the selected backend. */
+    async listProviders(opts = {}) {
+        if (this.disposed)
+            throw new Error("ACP agent runner is disposed");
+        opts.signal?.throwIfAborted();
+        const backend = selectBackend(opts, this.backends);
+        const connection = this.createDedicatedConnection(backend, () => undefined);
+        try {
+            const request = {
+                ...(opts.meta ? { _meta: opts.meta } : {}),
+            };
+            const response = await connection.listProviders(request, opts.label);
+            opts.signal?.throwIfAborted();
+            if (this.disposed)
+                throw new Error("ACP agent runner is disposed");
+            return response;
+        }
+        finally {
+            await disposeBestEffort(connection);
+        }
+    }
+    /** Configure one provider on the selected backend. */
+    async setProvider(opts) {
+        if (this.disposed)
+            throw new Error("ACP agent runner is disposed");
+        validateRequiredString(opts.providerId, opts.label, "setProvider", "providerId");
+        validateRequiredString(opts.apiType, opts.label, "setProvider", "apiType");
+        validateRequiredString(opts.baseUrl, opts.label, "setProvider", "baseUrl");
+        opts.signal?.throwIfAborted();
+        const backend = selectBackend(opts, this.backends);
+        const connection = this.createDedicatedConnection(backend, () => undefined);
+        try {
+            const request = {
+                providerId: opts.providerId,
+                apiType: opts.apiType,
+                baseUrl: opts.baseUrl,
+                ...(opts.headers ? { headers: opts.headers } : {}),
+                ...(opts.meta ? { _meta: opts.meta } : {}),
+            };
+            const response = await connection.setProvider(request, opts.label);
+            opts.signal?.throwIfAborted();
+            if (this.disposed)
+                throw new Error("ACP agent runner is disposed");
+            return response;
+        }
+        finally {
+            await disposeBestEffort(connection);
+        }
+    }
+    /** Disable one provider on the selected backend. */
+    async disableProvider(opts) {
+        if (this.disposed)
+            throw new Error("ACP agent runner is disposed");
+        validateRequiredString(opts.providerId, opts.label, "disableProvider", "providerId");
+        opts.signal?.throwIfAborted();
+        const backend = selectBackend(opts, this.backends);
+        const connection = this.createDedicatedConnection(backend, () => undefined);
+        try {
+            const request = {
+                providerId: opts.providerId,
+                ...(opts.meta ? { _meta: opts.meta } : {}),
+            };
+            const response = await connection.disableProvider(request, opts.label);
+            opts.signal?.throwIfAborted();
+            if (this.disposed)
+                throw new Error("ACP agent runner is disposed");
+            return response;
+        }
+        finally {
+            await disposeBestEffort(connection);
+        }
+    }
+    /** Logout through the selected backend. */
+    async logout(opts = {}) {
+        if (this.disposed)
+            throw new Error("ACP agent runner is disposed");
+        opts.signal?.throwIfAborted();
+        const backend = selectBackend(opts, this.backends);
+        const connection = this.createDedicatedConnection(backend, () => undefined);
+        try {
+            const request = {
+                ...(opts.meta ? { _meta: opts.meta } : {}),
+            };
+            const response = await connection.logout(request, opts.label);
+            opts.signal?.throwIfAborted();
+            if (this.disposed)
+                throw new Error("ACP agent runner is disposed");
+            return response;
+        }
+        finally {
+            await disposeBestEffort(connection);
+        }
+    }
     /** List persisted ACP sessions from the selected backend. */
     async listSessions(opts = {}) {
         if (this.disposed)
@@ -180,22 +311,24 @@ export class AcpAgentRunner {
             registry,
             signal: opts.signal,
         });
-        const session = await this.pool.acquire(prepared.backend, prepared.sessionOptions);
+        let session;
         try {
+            session = await this.pool.acquire(prepared.backend, prepared.sessionOptions);
+            const activeSession = session;
             opts.signal?.throwIfAborted();
             // For a CUSTOM backend chosen by its registered name, the name itself is routing, not a
             // model id: "browser" selects nothing; "browser/foo" selects "foo". Built-ins get the
             // full spec unchanged (their catalogs match provider-prefixed and bare ids).
-            await applyModelSelection(session, prepared.modelSpec, opts);
+            await applyModelSelection(activeSession, prepared.modelSpec, opts);
             opts.signal?.throwIfAborted();
             if (opts.mode)
-                await session.setMode(opts.mode);
+                await activeSession.setMode(opts.mode);
             const text = buildRunPrompt(prompt, opts, schema, prepared.backend);
             const initialPrompt = opts.images && opts.images.length > 0 ? promptWithImages(text, opts.images) : text;
             // Generic turn-scoped _meta passthrough merged UNDER the backend-computed keys (e.g. the
             // outputSchema forward when a schema is set) — user meta never clobbers the schema channel.
             const promptMeta = mergeTurnMeta(opts.promptMeta, prepared.backend.promptMeta(schema));
-            const response = await session.prompt(initialPrompt, promptMeta);
+            const response = await activeSession.prompt(initialPrompt, promptMeta);
             opts.signal?.throwIfAborted();
             // Inspect the turn's stop reason BEFORE the text/schema path: a refusal or truncation
             // must surface distinctly here, never be misread as empty output or burned through the
@@ -204,13 +337,13 @@ export class AcpAgentRunner {
             if (schema) {
                 const structuredSession = {
                     prompt: async (repromptText) => {
-                        const repromptResponse = await session.prompt(repromptText, promptMeta);
+                        const repromptResponse = await activeSession.prompt(repromptText, promptMeta);
                         // A repair turn that refuses / truncates / cancels must also surface distinctly
                         // instead of silently continuing the ladder.
                         assertNormalStopReason(repromptResponse.stopReason, opts.label);
                     },
-                    lastText: () => session.currentTurnText(),
-                    tryNative: () => prepared.backend.nativeStructured(session),
+                    lastText: () => activeSession.currentTurnText(),
+                    tryNative: () => prepared.backend.nativeStructured(activeSession),
                 };
                 const result = await resolveStructuredOutput(structuredSession, schema, {
                     maxSchemaRetries: opts.maxSchemaRetries,
@@ -219,7 +352,7 @@ export class AcpAgentRunner {
                 });
                 return result;
             }
-            const finalText = session.currentTurnText().trim();
+            const finalText = activeSession.currentTurnText().trim();
             if (!finalText) {
                 throw new WorkflowError("Subagent produced no assistant output", WorkflowErrorCode.AGENT_EMPTY_OUTPUT, {
                     recoverable: true,
@@ -232,28 +365,34 @@ export class AcpAgentRunner {
             // Abort is the engine's concern (throwIfAborted before/after the call) — re-throw it raw.
             if (opts.signal?.aborted)
                 throw error;
-            throw mapThrownError(error, opts.label);
+            throw mapThrownError(error, {
+                label: opts.label,
+                backendId: prepared.backend.id,
+                authMethods: session?.capabilities?.authMethods,
+            });
         }
         finally {
-            // Read real usage on BOTH success and error so partial usage is never lost.
-            try {
-                opts.onUsage?.(session.usage.toAgentUsage());
-            }
-            catch {
-                // usage is best-effort; never let it mask the real result/error.
-            }
-            try {
-                opts.onHistory?.(session.history);
-            }
-            catch {
-                // history is diagnostic only.
-            }
-            // Release the SESSION (best-effort session/close) WITHOUT killing the pooled process.
-            try {
-                await session.release();
-            }
-            catch {
-                // release is best-effort (session already untracked); never mask the real result/error.
+            if (session) {
+                // Read real usage on BOTH success and error so partial usage is never lost.
+                try {
+                    opts.onUsage?.(session.usage.toAgentUsage());
+                }
+                catch {
+                    // usage is best-effort; never let it mask the real result/error.
+                }
+                try {
+                    opts.onHistory?.(session.history);
+                }
+                catch {
+                    // history is diagnostic only.
+                }
+                // Release the SESSION (best-effort session/close) WITHOUT killing the pooled process.
+                try {
+                    await session.release();
+                }
+                catch {
+                    // release is best-effort (session already untracked); never mask the real result/error.
+                }
             }
         }
     }
@@ -320,7 +459,13 @@ export class AcpAgentRunner {
                 // best-effort: lifecycle setup failed, so teardown must never mask the real error.
             }
             await disposeBestEffort(connection);
-            throw error;
+            if (opts.signal?.aborted)
+                throw error;
+            throw mapThrownError(error, {
+                label: opts.label,
+                backendId: prepared.backend.id,
+                authMethods: connection.capabilities?.authMethods,
+            });
         }
     }
     createDedicatedConnection(backend, onDead) {
@@ -491,8 +636,11 @@ function validateOptionalLifecycleCwd(cwd, label, methodName) {
     validateInteractiveCwd(cwd, label, methodName);
 }
 function validateLifecycleSessionId(sessionId, label, methodName) {
-    if (typeof sessionId !== "string" || sessionId.trim() === "") {
-        throw new WorkflowError(`${methodName} requires sessionId to be a non-empty string`, WorkflowErrorCode.SCRIPT_VALIDATION_ERROR, { recoverable: false, agentLabel: label });
+    validateRequiredString(sessionId, label, methodName, "sessionId");
+}
+function validateRequiredString(value, label, methodName, fieldName) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new WorkflowError(`${methodName} requires ${fieldName} to be a non-empty string`, WorkflowErrorCode.SCRIPT_VALIDATION_ERROR, { recoverable: false, agentLabel: label });
     }
 }
 async function disposeBestEffort(connection) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automatalabs/acp-agents",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "license": "Apache-2.0",
   "engines": {
     "node": ">=22"
@@ -31,7 +31,7 @@
     "@agentclientprotocol/claude-agent-acp": "0.56.0",
     "@automatalabs/codex-acp": "1.4.0",
     "typebox": "1.3.2",
-    "@automatalabs/shared-types": "0.9.0"
+    "@automatalabs/shared-types": "0.11.0"
   },
   "scripts": {
     "build": "tsc -b",