@jigging/agent-acp 0.1.0-alpha.6 → 0.1.0-alpha.7

package/AGENTS.md

@@ -47,6 +47,9 @@ retains credential, process, and dispatch authority.
   closes the writer with `error: 'LAGGED'`; no clean EOF hides incomplete output.
   Closed native warning notices go to console diagnostics, not answer text or
   public events; the host strips raw metadata and rejects authoritative errors.
+- A native request rejection reports its known finite ACP method with
+  `EXECUTION_FAILED`, never the client's error text or data. That phase does not
+  establish the private cause, remote dispatch or permission to retry.
 - Optional conversational mode owns bounded direct commands/replies and per-turn
   results in `src/conversation.ts`. Native maxTurns, serial dispatch and interruption
   settlement remain host-enforced. One-shot calls retain their simple interface.

package/README.md

@@ -38,6 +38,10 @@ filesystem context are not supplied.
 
 Native warnings are separate, sanitized console diagnostics rather than answer
 text or Agent events. Authoritative native errors remain invocation failures.
+Rejected native requests report the failed ACP step, such as `session/new` or
+`session/prompt`, with `EXECUTION_FAILED`. The client's private error text and
+data are withheld. The step identifies where the rejection was received; it
+does not establish its cause, remote effects, or permission to repeat the call.
 
 For conversational use, add `conversation: true` to input and connect direct
 `commands` and `replies` channels from the complete contract bundle. Initial

package/dist/flow.js

@@ -3217,7 +3217,7 @@ class FinitePeer {
       if (frame.id !== id || Object.hasOwn(frame, "result") === Object.hasOwn(frame, "error"))
         failure("Native ACP response does not match its request");
       if (frame.error !== undefined)
-        throw new OperationError("EXECUTION_FAILED", "Native ACP request failed");
+        throw new OperationError("EXECUTION_FAILED", `Native ACP request failed during ${method}; private client details were withheld.`);
       return object2(frame.result);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jigging/agent-acp",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.7",
   "description": "An ordinary Agent Flow over a finite, host-authorized ACP resource",
   "license": "MPL-2.0",
   "repository": {

package/src/flow.ts

@@ -32,6 +32,13 @@ const RESPONSES = './contracts/finite-acp/responses.json'
 const MAX_TEXT_BYTES = 8_388_608
 
 type Settlement = { result: RunResult } | { error: unknown }
+type NativeRequestMethod =
+  | 'initialize'
+  | 'session/new'
+  | 'session/resume'
+  | 'session/set_config_option'
+  | 'session/set_mode'
+  | 'session/prompt'
 
 /** One replaceable method; process, credentials and reviewed policy stay outside. */
 export async function agentAcpFlow(run: RunContext): Promise<RunResult> {
@@ -261,7 +268,7 @@ class FinitePeer {
     private readonly updates: OptionalUpdates,
   ) {}
 
-  async request(method: string, params: JsonObject): Promise<JsonObject> {
+  async request(method: NativeRequestMethod, params: JsonObject): Promise<JsonObject> {
     const id = ++this.operation
     await this.write({ jsonrpc: '2.0', id, method, params })
     for (;;) {
@@ -275,7 +282,10 @@ class FinitePeer {
       if (frame.id !== id || Object.hasOwn(frame, 'result') === Object.hasOwn(frame, 'error'))
         failure('Native ACP response does not match its request')
       if (frame.error !== undefined)
-        throw new OperationError('EXECUTION_FAILED', 'Native ACP request failed')
+        throw new OperationError(
+          'EXECUTION_FAILED',
+          `Native ACP request failed during ${method}; private client details were withheld.`,
+        )
       return object(frame.result)
     }
   }

package/test/flow.test.ts

@@ -248,6 +248,54 @@ function fixture(options: Options = {}) {
   }
 }
 
+describe('native request failure diagnostics', () => {
+  test.each([
+    'initialize',
+    'session/new',
+    'session/resume',
+    'session/set_config_option',
+    'session/set_mode',
+    'session/prompt',
+  ])(
+    'identifies %s without exposing native error text or sending further requests',
+    async (method) => {
+      const restoring = method === 'session/resume'
+      const f = fixture({
+        ...(restoring
+          ? {
+              input: {
+                instructions: 'Continue.',
+                session: { restore: '013579ab-cdef-4567-89ab-0123456789ab' },
+              },
+              ready: { ...ready, restoreSessionId: 'owned-session' },
+            }
+          : {}),
+        async emit(frame, send) {
+          if (frame.method !== method) return false
+          await f.frameSend(send, {
+            jsonrpc: '2.0',
+            id: frame.id!,
+            error: {
+              code: -32603,
+              message: '/private/native-state secret-token rejected private-model',
+              data: { credential: 'secret-token', cause: 'untrusted native detail' },
+            },
+          })
+          return true
+        },
+      })
+      const failure = await agentAcpFlow(f.run).catch((error) => error)
+      expect(failure).toBeInstanceOf(OperationError)
+      expect(failure).toMatchObject({
+        code: 'EXECUTION_FAILED',
+        message: `Native ACP request failed during ${method}; private client details were withheld.`,
+      })
+      expect(f.frames.at(-1)?.method).toBe(method)
+      expect(f.stats()).toEqual({ calls: 1, cancelled: true, settled: true })
+    },
+  )
+})
+
 describe('ordinary session retention and restoration', () => {
   test.each(['active', 'settled'])(
     'notice display during %s does not enter answers or selected public events',