agentproc 0.7.1__tar.gz → 0.9.0__tar.gz

{agentproc-0.7.1 → agentproc-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentproc
-Version: 0.7.1
+Version: 0.9.0
 Summary: AgentProc Protocol SDK + CLI — connect any Agent CLI to a messaging platform
 License: MIT
 Project-URL: Homepage, https://github.com/jeffkit/agentproc

{agentproc-0.7.1 → agentproc-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentproc"
-version = "0.7.1"
+version = "0.9.0"
 description = "AgentProc Protocol SDK + CLI — connect any Agent CLI to a messaging platform"
 readme = "README.md"
 license = { text = "MIT" }

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/__init__.py

@@ -4,15 +4,15 @@ agentproc — AgentProc Protocol SDK (Python)
 Implements the AgentProc P0 protocol so you can write a single async handler
 instead of manually reading the turn from stdin and formatting stdout.
 
-Protocol contract (spec/protocol.md, wire protocol 0.3, NDJSON both directions):
+Protocol contract (spec/protocol.md, wire protocol 0.4, NDJSON both directions):
   Input  — stdin: one {"type":"turn",...} line (message, session_id,
                    session_name, from_user, attachments, permission,
                    protocol_version). Secrets/config stay in env.
   Output — stdout (one JSON object per line, discriminated by `type`):
              {"type":"partial","text":...}    — streaming chunk
-             {"type":"text","text":...}       — final reply body
-             {"type":"session","id":...}      — declare session id (last wins)
+             {"type":"result","text":...}     — terminal success body (at most one)
              {"type":"error","message":...}   — error message to forward to user
+           Optional ``session_id`` field on events (bridge persists first non-empty).
   Exit   — 0 success, 1 error, 124 timeout, 130 SIGINT, 143 SIGTERM
 
 Example::
@@ -166,6 +166,64 @@ class AgentContext:
         sys.stdout.flush()
         return _NoopAwaitable()
 
+    def send_permission_request(self, req: Dict[str, Any]) -> None:
+        """Send a tool-permission request to the bridge.
+
+        Only valid when ``ctx.permission`` is True (the profile set
+        ``permission: true`` and the bridge enabled the channel). The bridge
+        surfaces the request to the user; the matching decision arrives on
+        stdin as a ``{"type":"permission_response",...}`` frame that
+        :meth:`read_permission_response` decodes.
+
+        ``req`` MUST include ``request_id`` (unique within the turn),
+        ``tool_name``, and ``input`` (object). ``description`` and
+        ``tool_use_id`` are optional.
+        """
+        if not self.permission:
+            raise RuntimeError(
+                "ctx.send_permission_request() requires profile.permission: "
+                "true — the bridge would otherwise not honor the request"
+            )
+        if not isinstance(req, dict):
+            raise TypeError("req must be a dict")
+        rid = req.get("request_id")
+        if not isinstance(rid, str) or not rid:
+            raise ValueError("req['request_id'] is required")
+        payload: Dict[str, Any] = {"type": "permission_request"}
+        for k in ("request_id", "tool_name", "input"):
+            payload[k] = req.get(k)
+        for k in ("description", "tool_use_id"):
+            if k in req:
+                payload[k] = req[k]
+        sys.stdout.write(
+            json.dumps(payload, ensure_ascii=False, separators=(",", ":")) + "\n"
+        )
+        sys.stdout.flush()
+
+    def read_permission_response(self) -> Optional[Dict[str, Any]]:
+        """Read the next ``{"type":"permission_response",...}`` frame from stdin.
+
+        Blocks until a frame arrives (or EOF). Returns the parsed object, or
+        ``None`` at EOF.
+
+        Only meaningful when ``ctx.permission`` is True — in the default
+        ``permission: false`` mode the bridge closes stdin after the turn
+        line, so this returns ``None`` immediately.
+        """
+        try:
+            line = sys.stdin.readline()
+        except Exception:
+            return None
+        if not line:
+            return None
+        try:
+            v = json.loads(line.rstrip("\r\n"))
+        except json.JSONDecodeError:
+            return None
+        if isinstance(v, dict):
+            return v
+        return None
+
 
 @dataclass
 class AgentResult:
@@ -195,7 +253,7 @@ def session_file_path(session_id: str, base_dir: Optional[str] = None) -> Path:
     Returns the path even if the file does not yet exist. Raises ``ValueError``
     when ``session_id`` is empty — callers should guard with ``if session_id``.
 
-    In wire 0.3 a session id is an arbitrary JSON string on the wire, but the
+    In wire 0.4 a session id is an arbitrary JSON string on the wire, but the
     SDK stores each session as ``<id>.jsonl``; an id that is not a storage-safe
     filename component (path separators, control chars, ``.``/``..``) would
     path-traverse out of the sessions directory and is rejected here. See
@@ -346,18 +404,13 @@ def create_profile(handler: Handler) -> None:
     if isinstance(result, str):
         result = AgentResult(response=result)
 
-    # session event — emitted last in the typical "I just learned it" flow,
-    # but the spec says last wins, so emitting it at the end is correct.
-    if result.session_id:
-        sys.stdout.write(
-            json.dumps({"type": "session", "id": result.session_id}, ensure_ascii=False, separators=(',', ':')) + "\n"
-        )
-        sys.stdout.flush()
-
-    if result.response:
-        sys.stdout.write(
-            json.dumps({"type": "text", "text": result.response}, ensure_ascii=False, separators=(',', ':')) + "\n"
-        )
+    # Emit a single {"type":"result"} carrying the reply body and optional
+    # session_id. Wire 0.4 removed dedicated session/text events.
+    if result.response or result.session_id:
+        evt: Dict[str, Any] = {"type": "result", "text": result.response or ""}
+        if result.session_id:
+            evt["session_id"] = result.session_id
+        sys.stdout.write(json.dumps(evt, ensure_ascii=False, separators=(',', ':')) + "\n")
         sys.stdout.flush()
 
     sys.exit(0)

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/cli.py

@@ -58,7 +58,7 @@ PKG_VERSION = _read_pkg_version()
 def _build_attachments(opts) -> List[Dict[str, str]]:
     """Build the turn's `attachments` array from --image-url / --file-url.
 
-    Wire 0.3 carries attachments as a single `attachments` list; there are no
+    Wire 0.4 carries attachments as a single `attachments` list; there are no
     separate AGENT_IMAGE_URL / AGENT_FILE_URL channels. Returns an empty list
     when no attachment flags were given (the runner omits the key when empty).
     """

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/README.md

@@ -74,18 +74,18 @@ NDJSON-based profiles (`claude-code`, `codex`, `codebuddy`, `gemini-cli`, `qwen-
 3. **Adjust** `cwd:` in the profile to point at your project.
 4. **Point your bridge** at the profile YAML. The exact command depends on your bridge.
 
-Example with the Python SDK's bare runner (wire 0.3 — the turn object arrives on stdin as one NDJSON line):
+Example with the Python SDK's bare runner (wire 0.4 — the turn object arrives on stdin as one NDJSON line):
 
 ```bash
 cd hub/claude-code
-echo '{"type":"turn","message":"hello","session_id":"","from_user":"u1","protocol_version":"0.3"}' | python3 bridge.py
+echo '{"type":"turn","message":"hello","session_id":"","from_user":"u1","protocol_version":"0.4"}' | python3 bridge.py
 ```
 
 You should see AgentProc protocol output on stdout (one NDJSON event per line):
 
 ```
-{"type":"partial","text":"Hi! How can I help?"}
-{"type":"session","id":"cli-sess-9f3a2c1e-4b8d-4a2f-b6c1-2e8d4f5a7b9c"}
+{"type":"partial","text":"Hi! How can I help?","session_id":"cli-sess-9f3a2c1e-4b8d-4a2f-b6c1-2e8d4f5a7b9c"}
+{"type":"result","text":"","session_id":"cli-sess-9f3a2c1e-4b8d-4a2f-b6c1-2e8d4f5a7b9c"}
 ```
 
 ## Design principles
@@ -116,7 +116,7 @@ description: <one-line>
 cli: <command-name>             # the executable this wraps
 cli_install: |                  # how to install the CLI itself
   npm install -g ...
-agentproc:                      # the actual AgentProc P0 profile (wire 0.3)
+agentproc:                      # the actual AgentProc P0 profile (wire 0.4)
   command: python3              # argv[0] — always a single token, never split
   args: ["{{PROFILE_DIR}}/bridge.py"]  # argv[1..]; or: ["{{PROFILE_DIR}}/bridge.js"] for node
   # cwd intentionally omitted: `hub run` defaults it to the user's

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/_shared/README.md

@@ -1,6 +1,6 @@
 # hub/_shared
 
-Shared bridge utilities used by the hub profiles (wire 0.3). The Python and
+Shared bridge utilities used by the hub profiles (wire 0.4). The Python and
 Node implementations stay at parity: same input contract, same output contract.
 
 ## What it does
@@ -11,9 +11,10 @@ NDJSON-speaking CLI:
 - reading the `{"type":"turn",...}` object from stdin (one NDJSON line)
 - subprocess spawn + `FileNotFoundError` → `{"type":"error"}`
 - line-by-line stdout reading + JSON decoding
-- partial / final / session / error classification → NDJSON events
+- partial / result / error classification → NDJSON events (`session_id` stamped on events once known)
 - always-emit-partial policy (the runner forwards `{"type":"partial"}` only
-  when the profile's `streaming` is true) + dedup
+  when the profile's `streaming` is true) + stamping `session_id` on partials
+  once known
 - exit-code mapping + stderr capture
 
 A bridge that wraps an NDJSON-speaking CLI only needs to provide two functions:
@@ -32,9 +33,10 @@ function parseEvent(event) { return { partialText?, finalText?, sessionId?, erro
 
 `run_bridge` / `runBridge` then: read the turn from stdin, spawn the CLI built
 by `build_args`, call `parse_event` on each stdout NDJSON line, and emit
-AgentProc NDJSON events on stdout. A final `{"type":"text"}` event is always
+AgentProc NDJSON events on stdout. A final `{"type":"result"}` event is always
 emitted at the end (the `final_text`, or the last `partial_text` as fallback) —
-that is the reply body.
+that is the reply body. `session_id` rides on partial / result / error events
+(not a separate session event).
 
 That keeps each bridge under ~50 lines. See `gemini-cli/bridge.py` for a
 minimal example.
@@ -49,7 +51,7 @@ assembled" event that follows the delta stream — see `cursor/bridge.py`'s
 CLIs that return the full reply as plain stdout (no streaming, no session id) —
 `aider`, `pi`, `deepseek`, `agy` — use `run_plain_cli` / `runPlainCli` instead.
 It reads the turn, runs the CLI with a timeout, and emits the trimmed stdout as
-a single `{"type":"text"}` event (or `{"type":"error"}` on failure). The bridge
+a single `{"type":"result"}` event (or `{"type":"error"}` on failure). The bridge
 only supplies `build_args(message)`.
 
 ## When NOT to use it
@@ -72,7 +74,7 @@ The shared module distinguishes two text channels:
 - `partial_text` — incremental chunks emitted mid-turn as `{"type":"partial"}`
   (the bridge always emits these; the runner forwards them only when the
   profile's `streaming` is true).
-- `final_text` — terminal text, emitted as the final `{"type":"text"}` reply
+- `final_text` — terminal text, emitted as the final `{"type":"result"}` reply
   event (used as-is when present, otherwise the last `partial_text` is the
   fallback).
 

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/_shared/stream_utils.js

@@ -1,19 +1,20 @@
 'use strict';
 
 /**
- * Shared bridge utilities for AgentProc hub profiles (wire 0.3).
+ * Shared bridge utilities for AgentProc hub profiles (wire 0.4).
  *
  * A bridge wraps a CLI that emits NDJSON (one JSON object per line) on stdout.
  * The bridge reads the {"type":"turn",...} object from its own stdin, spawns
- * the CLI, and translates the CLI's NDJSON stream into AgentProc wire-0.3
+ * the CLI, and translates the CLI's NDJSON stream into AgentProc wire-0.4
  * output (one JSON event per line on stdout):
  *
- *   - {"type":"partial","text":...}   live streaming chunk (always emitted;
- *                                      the runner forwards it only when the
- *                                      profile's streaming is true)
- *   - {"type":"session","id":...}     declare session id (last wins)
- *   - {"type":"error","message":...}  error message (always honored, exit 1)
- *   - {"type":"text","text":...}      final reply body (emitted once at end)
+ *   - {"type":"partial","text":...,"session_id"?}  live streaming chunk
+ *      (always emitted; the runner forwards it only when the profile's
+ *      streaming is true). session_id is stamped when already known.
+ *   - {"type":"result","text":...,"session_id"?}   single terminal reply
+ *      (emitted once at end; text may be "" if the body was already streamed)
+ *   - {"type":"error","message":...,"session_id"?} error (exit 1); may
+ *      carry session_id so the session survives an error-terminated turn
  *
  * A profile supplies:
  *
@@ -35,24 +36,26 @@ function emitObj(obj) {
 
 function emit(obj) {
   // Emit one NDJSON event dict. Bridges may pass a pre-built event dict; for
-  // the common cases use emitPartial / emitText / emitSession / emitError.
+  // the common cases use emitPartial / emitResult / emitError.
   emitObj(obj);
 }
 
-function emitPartial(text) {
-  emitObj({ type: 'partial', text });
-}
-
-function emitText(text) {
-  emitObj({ type: 'text', text });
+function emitPartial(text, sessionId) {
+  const obj = { type: 'partial', text };
+  if (sessionId) obj.session_id = sessionId;
+  emitObj(obj);
 }
 
-function emitError(text) {
-  emitObj({ type: 'error', message: text });
+function emitResult(text, sessionId) {
+  const obj = { type: 'result', text };
+  if (sessionId) obj.session_id = sessionId;
+  emitObj(obj);
 }
 
-function emitSession(sessionId) {
-  emitObj({ type: 'session', id: sessionId });
+function emitError(text, sessionId) {
+  const obj = { type: 'error', message: text };
+  if (sessionId) obj.session_id = sessionId;
+  emitObj(obj);
 }
 
 function hasAnyAttachment(turn) {
@@ -129,15 +132,17 @@ async function runBridge({ cliName, cliInstallHint, buildArgs, parseEvent, turn
     const result = parseEvent(event);
     if (!result) continue;
 
+    // Capture sessionId before emitting partials so same-event session
+    // stamps the partial (runner first-non-empty wins if it arrives later).
     if (result.sessionId) foundSessionId = result.sessionId;
     if (result.error) errorMessage = result.error;
     if (result.partialText) {
       // Always emit partials; the runner forwards them only when the profile's
       // streaming is true (and drops them otherwise).
-      emitPartial(result.partialText);
+      emitPartial(result.partialText, foundSessionId);
       lastPartialText = result.partialText;
     }
-    if (result.finalText) {
+    if (result.finalText !== undefined && result.finalText !== null) {
       lastFinalText = result.finalText;
     }
   }
@@ -145,8 +150,7 @@ async function runBridge({ cliName, cliInstallHint, buildArgs, parseEvent, turn
   const code = await new Promise(resolve => child.on('close', resolve));
 
   if (errorMessage) {
-    if (foundSessionId) emitSession(foundSessionId);
-    emitError(errorMessage);
+    emitError(errorMessage, foundSessionId);
     process.exit(1);
   }
   if (code !== 0 && !foundSessionId) {
@@ -157,16 +161,15 @@ async function runBridge({ cliName, cliInstallHint, buildArgs, parseEvent, turn
     process.exit(1);
   }
 
-  if (foundSessionId) emitSession(foundSessionId);
   const replyText = (lastFinalText !== null) ? lastFinalText : lastPartialText;
-  if (replyText) emitText(replyText);
+  emitResult(replyText || '', foundSessionId);
   process.exit(0);
 }
 
 async function runPlainCli({ cliName, cliInstallHint, buildArgs, timeoutEnv = 'CLI_TIMEOUT', defaultTimeout = 600 }) {
   // Drive a one-shot CLI that returns the full reply as plain stdout text
   // (no streaming, no session id). Reads the turn from stdin, runs the CLI
-  // with a timeout, and emits the trimmed stdout as a single {"type":"text"}
+  // with a timeout, and emits the trimmed stdout as a single {"type":"result"}
   // event (or {"type":"error"} on failure). buildArgs(message) builds the
   // argv; per-CLI config is read from process.env inside buildArgs.
   const turn = await readTurn();
@@ -214,7 +217,7 @@ async function runPlainCli({ cliName, cliInstallHint, buildArgs, timeoutEnv = 'C
     emitError(`${cliName} returned empty output`);
     process.exit(1);
   }
-  emitText(text);
+  emitResult(text);
   process.exit(0);
 }
 
@@ -224,7 +227,6 @@ module.exports = {
   readTurn,
   emit,
   emitPartial,
-  emitText,
+  emitResult,
   emitError,
-  emitSession,
 };

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/_shared/stream_utils.py

@@ -1,17 +1,18 @@
 """
-Shared bridge utilities for AgentProc hub profiles (wire 0.3).
+Shared bridge utilities for AgentProc hub profiles (wire 0.4).
 
 A bridge wraps a CLI that emits NDJSON (one JSON object per line) on stdout.
 The bridge reads the {"type":"turn",...} object from its own stdin, spawns the
-CLI, and translates the CLI's NDJSON stream into AgentProc wire-0.3 output
+CLI, and translates the CLI's NDJSON stream into AgentProc wire-0.4 output
 (one JSON event per line on stdout):
 
-  - {"type":"partial","text":...}   — live streaming chunk (always emitted;
-                                       the runner forwards it only when the
-                                       profile's streaming is true)
-  - {"type":"session","id":...}     — declare session id (last wins)
-  - {"type":"error","message":...}  — error message (always honored, exit 1)
-  - {"type":"text","text":...}      — final reply body (emitted once at end)
+  - {"type":"partial","text":...,"session_id"?}  — live streaming chunk
+      (always emitted; the runner forwards it only when the profile's
+      streaming is true). session_id is stamped when already known.
+  - {"type":"result","text":...,"session_id"?}   — single terminal reply
+      (emitted once at end; text may be "" if the body was already streamed)
+  - {"type":"error","message":...,"session_id"?} — error (exit 1); may
+      carry session_id so the session survives an error-terminated turn
 
 A profile supplies:
 
@@ -40,7 +41,7 @@ from typing import Any, Callable, Dict, Optional
 class EventResult:
     # Incremental text streamed mid-turn → emitted as a {"type":"partial"} event.
     partial_text: Optional[str] = None
-    # Terminal text — the final assembled reply → emitted as a {"type":"text"}
+    # Terminal text — the final assembled reply → emitted as a {"type":"result"}
     # event at end. When a CLI only produces a single completed message (no
     # deltas), set this; if a bridge marks it partial_text instead, the last
     # partial_text is used as the reply fallback.
@@ -56,25 +57,30 @@ def _emit_obj(obj: Dict[str, Any]) -> None:
 
 def emit(obj: Dict[str, Any]) -> None:
     """Emit one NDJSON event dict on stdout. (Bridges may pass a pre-built
-    event dict; for the common cases use emit_partial / emit_text /
-    emit_session / emit_error instead.)"""
+    event dict; for the common cases use emit_partial / emit_result /
+    emit_error instead.)"""
     _emit_obj(obj)
 
 
-def emit_partial(text: str) -> None:
-    _emit_obj({"type": "partial", "text": text})
-
-
-def emit_text(text: str) -> None:
-    _emit_obj({"type": "text", "text": text})
+def emit_partial(text: str, session_id: Optional[str] = None) -> None:
+    obj: Dict[str, Any] = {"type": "partial", "text": text}
+    if session_id:
+        obj["session_id"] = session_id
+    _emit_obj(obj)
 
 
-def emit_session(session_id: str) -> None:
-    _emit_obj({"type": "session", "id": session_id})
+def emit_result(text: str, session_id: Optional[str] = None) -> None:
+    obj: Dict[str, Any] = {"type": "result", "text": text}
+    if session_id:
+        obj["session_id"] = session_id
+    _emit_obj(obj)
 
 
-def emit_error(text: str) -> None:
-    _emit_obj({"type": "error", "message": text})
+def emit_error(text: str, session_id: Optional[str] = None) -> None:
+    obj: Dict[str, Any] = {"type": "error", "message": text}
+    if session_id:
+        obj["session_id"] = session_id
+    _emit_obj(obj)
 
 
 def _read_turn() -> Dict[str, Any]:
@@ -87,10 +93,11 @@ def _read_turn() -> Dict[str, Any]:
         return {}
     try:
         v = json.loads(line.rstrip("\r\n"))
-        if isinstance(v, dict):
-            return v
     except json.JSONDecodeError:
         pass
+    else:
+        if isinstance(v, dict):
+            return v
     return {}
 
 
@@ -113,7 +120,7 @@ def run_bridge(
     turn: Optional[Dict[str, Any]] = None,
 ) -> int:
     """
-    Drive a CLI as an AgentProc agent (wire 0.3).
+    Drive a CLI as an AgentProc agent (wire 0.4).
 
     Reads the turn object from stdin (unless ``turn`` is passed — used by
     bridges that need to inspect the turn, e.g. to refuse ``permission: true``
@@ -164,6 +171,8 @@ def run_bridge(
         if result is None:
             continue
 
+        # Capture session_id before emitting partials so same-event session
+        # stamps the partial (runner first-non-empty wins if it arrives later).
         if result.session_id:
             found_session_id = result.session_id
         if result.error:
@@ -171,20 +180,18 @@ def run_bridge(
         if result.partial_text:
             # Always emit partials; the runner forwards them only when the
             # profile's streaming is true (and drops them otherwise).
-            emit_partial(result.partial_text)
+            emit_partial(result.partial_text, session_id=found_session_id)
             last_partial_text = result.partial_text
-        if result.final_text:
+        if result.final_text is not None:
             last_final_text = result.final_text
 
     proc.wait()
     stderr_output = proc.stderr.read() if proc.stderr else ""
 
     if error_message:
-        # Persist the session for the next turn BEFORE emitting the error —
-        # the error terminates this turn but does not invalidate the session.
-        if found_session_id:
-            emit_session(found_session_id)
-        emit_error(error_message)
+        # Persist the session on the error event — the error terminates this
+        # turn but does not invalidate the session.
+        emit_error(error_message, session_id=found_session_id)
         return 1
     if proc.returncode != 0 and not found_session_id:
         msg = f"{cli_name} exited with {proc.returncode}"
@@ -193,11 +200,8 @@ def run_bridge(
         emit_error(msg)
         return 1
 
-    if found_session_id:
-        emit_session(found_session_id)
     reply_text = last_final_text if last_final_text is not None else last_partial_text
-    if reply_text:
-        emit_text(reply_text)
+    emit_result(reply_text or "", session_id=found_session_id)
     return 0
 
 
@@ -231,7 +235,7 @@ def run_plain_cli(
     """Drive a one-shot CLI that returns the full reply as plain stdout text
     (no streaming, no session id). Reads the turn from stdin, runs the CLI
     with a timeout, and emits the trimmed stdout as a single
-    ``{"type":"text"}`` event (or ``{"type":"error"}`` on failure).
+    ``{"type":"result"}`` event (or ``{"type":"error"}`` on failure).
 
     ``build_args(message) -> list[str]`` builds the argv; per-CLI config
     (model, api key, …) is read from ``os.environ`` inside ``build_args`` as
@@ -271,7 +275,7 @@ def run_plain_cli(
 
     text = (proc.stdout or "").strip()
     if text:
-        emit_text(text)
+        emit_result(text)
         return 0
     emit_error(f"{cli_name} returned empty output")
     return 1

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/agy/README.md

@@ -61,14 +61,14 @@ Expected output (on stdout):
 agy ok
 ```
 
-(No `{"type":"session"}` line — see "Session continuity" below.)
+(No `session_id` on events — see "Session continuity" below.)
 
 <details>
 <summary>Drive the bridge script directly (without the CLI)</summary>
 
 ```bash
 cd hub/agy
-echo '{"type":"turn","message":"reply with exactly: agy ok","session_id":"","from_user":"u1","protocol_version":"0.3"}' | python3 bridge.py
+echo '{"type":"turn","message":"reply with exactly: agy ok","session_id":"","from_user":"u1","protocol_version":"0.4"}' | python3 bridge.py
 ```
 
 </details>
@@ -83,12 +83,12 @@ bridge.py / bridge.js
 agy CLI
   ↓ plain text reply on stdout (after the turn completes)
 bridge.py / bridge.js
-  ↓ reply body (no {"type":"session"} line, no {"type":"partial"} lines)
+  ↓ reply body (no session_id on events, no {"type":"partial"} lines)
 ```
 
 ## Session continuity
 
-**agy's `--print` mode does not expose a session id on stdout.** The bridge therefore emits no `{"type":"session"}` line. Each AgentProc turn spawns a fresh agy process.
+**agy's `--print` mode does not expose a session id on stdout.** The bridge therefore omits `session_id` on events. Each AgentProc turn spawns a fresh agy process.
 
 If your messaging bridge needs multi-turn context, use the [AgentProc SDK](https://agentproc.dev/sdk/python)'s history helpers (`load_history` / `append_history`) to maintain context in a JSONL file keyed by the messaging bridge's own session id. The [Python SDK history example](https://agentproc.dev/sdk/python#conversation-history) shows the pattern.
 

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/agy/bridge.js

@@ -5,7 +5,7 @@
  *
  * agy's --print mode returns the full reply as plain text — no streaming, no
  * exposed session id. The bridge forwards the text as the reply body (a single
- * {"type":"text"} event).
+ * {"type":"result"} event).
  *
  * Per-CLI config (read from the process env the runner injects):
  *   AGY_MODEL   Optional model override

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/agy/bridge.py

@@ -4,7 +4,7 @@ AgentProc bridge for the `agy` CLI (wire 0.3).
 
 agy's --print mode returns the full reply as plain text — no streaming, no
 exposed session id. The bridge forwards the text as the reply body (a single
-{"type":"text"} event).
+{"type":"result"} event).
 
 Per-CLI config (read from the process env the runner injects):
     AGY_MODEL   Optional model override

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/agy/profile.yaml

@@ -20,7 +20,7 @@ notes: |
   completes — it does not stream chunks and does not expose a resumable
   session id on stdout. As a result:
 
-    - No {"type":"session"} line is emitted (AgentProc allows this).
+    - No session_id is stamped on events (AgentProc allows this).
     - Each turn is a fresh agy process; multi-turn continuity must be
       maintained by the messaging bridge (e.g. via the AgentProc SDK's
       load_history / append_history helpers) rather than by agy itself.

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/aider/README.md

@@ -54,7 +54,7 @@ env_allowlist: [AIDER_MODEL, ANTHROPIC_API_KEY, OPENAI_API_KEY]
 
 ```bash
 cd hub/aider
-echo '{"type":"turn","message":"reply with exactly: aider ok (do not edit any files)","session_id":"","from_user":"u1","protocol_version":"0.3"}' | python3 bridge.py
+echo '{"type":"turn","message":"reply with exactly: aider ok (do not edit any files)","session_id":"","from_user":"u1","protocol_version":"0.4"}' | python3 bridge.py
 ```
 
 Expected: stdout contains `aider ok` (plus aider's usual banner/summary output).
@@ -70,7 +70,7 @@ aider CLI
   ↓ reads cwd via repo map → LLM → edits files → optional git commit
   ↓ human-readable summary on stdout (after the turn completes)
 bridge.py / bridge.js
-  ↓ reply body (no {"type":"session"} line, no {"type":"partial"} lines)
+  ↓ reply body (no session_id on events, no {"type":"partial"} lines)
 ```
 
 ## Session continuity
@@ -92,7 +92,7 @@ For projects without git, there is no automatic context continuity. Use the [Age
 
 - **Modifies files.** aider edits your working directory. Run it in a git repo so you can review and revert changes.
 - **No streaming.** `--no-stream` returns the full response at the end.
-- **No {"type":"session"}.** Session continuity is git-based, not AgentProc-native. The bridge emits no `{"type":"session"}` line.
+- **No `session_id` on events.** Session continuity is git-based, not AgentProc-native. The bridge omits `session_id` on events.
 - **No explicit file targeting.** The bridge does not pass specific files; aider uses its repo-map heuristic to find relevant files. Add files to aider's context by including them in your message (e.g. `"edit src/utils.py: add type hints"`).
 - **Auto-confirm.** `--yes-always` bypasses all aider confirmation prompts. Aider will edit and commit without asking.
 

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/aider/bridge.js

@@ -8,7 +8,7 @@
  *
  * aider modifies files in cwd and may make git commits. Its stdout (a
  * human-readable summary) is forwarded as the reply body (a single
- * {"type":"text"} event). No session id is emitted.
+ * {"type":"result"} event). No session id is emitted.
  *
  * Per-CLI config (read from the process env the runner injects):
  *   AIDER_MODEL   Optional model override (e.g. "claude-opus-4-5")

{agentproc-0.7.1 → agentproc-0.9.0}/src/agentproc/hub_data/aider/bridge.py

@@ -8,7 +8,7 @@ Invokes:
 
 aider modifies files in the working directory and may make git commits.
 The stdout output (a human-readable summary of what was done) is forwarded
-as the AgentProc reply body (a single {"type":"text"} event). No session id
+as the AgentProc reply body (a single {"type":"result"} event). No session id
 is emitted — aider uses git history for context continuity, not an explicit
 session id.