deepagent-vscode 0.2.0__tar.gz → 0.2.1__tar.gz

deepagent_vscode-0.2.1/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: deepagent-vscode
+Version: 0.2.1
+Summary: RENAMED: this package is now 'langstage-vscode' (LangStage family). Installing this pulls the new package.
+Project-URL: Homepage, https://github.com/dkedar7/langstage-vscode
+Author-email: Kedar Dabhadkar <kdabhadk@gmail.com>
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: langstage-vscode>=0.3.0
+Description-Content-Type: text/markdown
+
+# deepagent-vscode → langstage-vscode
+
+**This package has been renamed to [langstage-vscode](https://pypi.org/project/langstage-vscode/)** — part of the
+LangStage family rename ("every stage for your LangGraph agent").
+
+This final `deepagent-vscode` release simply depends on `langstage-vscode`, so existing installs keep
+working: the new package ships a deprecated import-alias for the old module
+name and keeps the old console command as an alias.
+
+Please update your dependencies:
+
+```bash
+pip install langstage-vscode
+```

deepagent_vscode-0.2.1/README.md

@@ -0,0 +1,14 @@
+# deepagent-vscode → langstage-vscode
+
+**This package has been renamed to [langstage-vscode](https://pypi.org/project/langstage-vscode/)** — part of the
+LangStage family rename ("every stage for your LangGraph agent").
+
+This final `deepagent-vscode` release simply depends on `langstage-vscode`, so existing installs keep
+working: the new package ships a deprecated import-alias for the old module
+name and keeps the old console command as an alias.
+
+Please update your dependencies:
+
+```bash
+pip install langstage-vscode
+```

deepagent_vscode-0.2.1/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "deepagent-vscode"
+version = "0.2.1"
+description = "RENAMED: this package is now 'langstage-vscode' (LangStage family). Installing this pulls the new package."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Kedar Dabhadkar", email = "kdabhadk@gmail.com" }]
+dependencies = ["langstage-vscode>=0.3.0"]
+
+[project.urls]
+Homepage = "https://github.com/dkedar7/langstage-vscode"
+
+[tool.hatch.build.targets.wheel]
+bypass-selection = true

deepagent_vscode-0.2.0/.gitignore

@@ -1,12 +0,0 @@
-# Python
-__pycache__/
-*.pyc
-*.egg-info/
-.venv/
-build/
-dist/
-
-# Node / VS Code extension
-extension/node_modules/
-extension/dist/
-*.vsix

deepagent_vscode-0.2.0/CHANGELOG.md

@@ -1,23 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-## [0.2.0] - 2026-06-10
-
-First PyPI release of the sidecar (`pip install deepagent-vscode`).
-
-### Added
-
-- **Family-standard config chain** — the sidecar resolves through the shared `HostConfig`: defaults < `deepagents.toml` (global + project) < `DEEPAGENT_*` env < CLI flags. A project `deepagents.toml` with `[agent] spec = "..."` now just works.
-- **`--demo`** — run with the shared keyless echo agent (`langgraph_stream_parser.demo.stub:graph`); no API key needed.
-- **`--show-config`** — print each resolved value with its source and the env var / TOML key that sets it.
-- **Extension**: an empty `deepagent.agentSpec` setting no longer hard-errors — the extension spawns the sidecar without `--agent` (cwd anchored at the workspace) and lets the config chain resolve.
-- README: *One agent, every surface* family table.
-
-### Changed
-
-- `langgraph-stream-parser` pinned `>=0.2.2,<0.3`.
-
-## [0.1.0] - 2026-06-04
-
-Initial version (GitHub only): stdio sidecar bridging LangGraph agents to the `@deepagent` VS Code chat participant, speaking the `langgraph-stream-parser` `event.to_dict()` wire vocabulary.

deepagent_vscode-0.2.0/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Kedar Dabhadkar
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

deepagent_vscode-0.2.0/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.4
-Name: deepagent-vscode
-Version: 0.2.0
-Summary: Python stdio sidecar bridging LangGraph/deepagents agents to the deepagent-vscode chat extension
-Author: Kedar Dabhadkar
-License-Expression: MIT
-License-File: LICENSE
-Keywords: agents,ai,deepagents,langgraph,vscode
-Requires-Python: >=3.11
-Requires-Dist: langgraph-stream-parser<0.3,>=0.2.2
-Provides-Extra: demo
-Requires-Dist: deepagents>=0.3; extra == 'demo'
-Provides-Extra: dev
-Requires-Dist: langchain-core>=1.4.0; extra == 'dev'
-Requires-Dist: langgraph>=1.1.0; extra == 'dev'
-Requires-Dist: pytest>=8; extra == 'dev'

deepagent_vscode-0.2.0/README.md

@@ -1,158 +0,0 @@
-<p align="center">
-  <img src="assets/header.svg" alt="deepagent-vscode" width="100%">
-</p>
-
-# deepagent-vscode
-
-Chat with your own **LangGraph / deepagents** agent from inside VS Code — in the
-same chat panel as Copilot — via the `@deepagent` chat participant.
-
-It has two parts in one repo:
-
-- **`extension/`** — a TypeScript VS Code extension that registers the
-  `@deepagent` chat participant and renders agent output in the chat view.
-- **`deepagent_vscode/`** — a small Python **stdio sidecar** that loads your
-  agent and streams its events. Built on
-  [`langgraph-stream-parser`](https://github.com/dkedar7/langgraph-stream-parser),
-  so it speaks the same typed event vocabulary as the other deep-agent surfaces
-  (`cowork-dash`, `deepagent-lab`, `deepagent-code`).
-
-```
-┌─ VS Code chat panel ────────────────────────────┐
-│  @deepagent  (TypeScript extension)              │
-│        │  spawns                                 │
-│        ▼                                          │
-│  python -m deepagent_vscode   (stdio sidecar)    │
-│        │  NDJSON over stdin/stdout               │
-│        ▼                                          │
-│  your LangGraph / deepagents agent               │
-└──────────────────────────────────────────────────┘
-```
-
-> **Status: early.** The extension is not yet on the VS Code Marketplace (run
-> it from source for now), and interactive approval of human-in-the-loop
-> interrupts is not wired into the chat UI yet (the sidecar already supports
-> the round-trip).
-
-## One agent, every surface
-
-deepagent-vscode is the VS Code surface of the **deep-agent family**: write your agent once — any LangGraph `CompiledGraph` — and run it on every surface with the same spec string (`module:attr` or `path/to/file.py:attr`), the same `deepagents.toml` config file, and the same `DEEPAGENT_*` environment variables.
-
-| Surface | Package | Try it |
-|---|---|---|
-| Web app | [cowork-dash](https://github.com/dkedar7/cowork-dash) | `cowork-dash run --agent my_agent.py:graph` |
-| JupyterLab | [deepagent-lab](https://github.com/dkedar7/deepagent-lab) | `pip install deepagent-lab`, then the chat sidebar in `jupyter lab` |
-| Terminal | [deepagent-code](https://github.com/dkedar7/deepagent-code) | `deepagent-code -a my_agent.py:graph` |
-| VS Code | deepagent-vscode | **you are here** |
-| Reference agent | [deepagent-hermes](https://github.com/dkedar7/deepagent-hermes) | `DEEPAGENT_AGENT_SPEC=deepagent_hermes.agent:graph` on any surface |
-| Shared core | [langgraph-stream-parser](https://github.com/dkedar7/langgraph-stream-parser) | typed events + config resolver behind every surface |
-
-## Install
-
-### Sidecar (Python)
-
-```bash
-pip install deepagent-vscode
-# or, for a quick try with the bundled default agent:
-pip install "deepagent-vscode[demo]"
-```
-
-### Extension (from source, until it's on the Marketplace)
-
-```bash
-cd extension
-npm install
-npm run compile
-```
-
-Then press **F5** in VS Code (with the `extension/` folder open) to launch an
-Extension Development Host with `@deepagent` available.
-
-## Configure
-
-In VS Code settings:
-
-| Setting | Description | Default |
-|---|---|---|
-| `deepagent.agentSpec` | Your agent, as `path/to/agent.py:graph` or `module:graph` | _(falls back to `DEEPAGENT_AGENT_SPEC` / `deepagents.toml`)_ |
-| `deepagent.pythonPath` | Python interpreter that has `deepagent-vscode` installed | `python` |
-
-The sidecar resolves its configuration through the family-standard chain —
-**defaults < `deepagents.toml` (global + project) < `DEEPAGENT_*` env < CLI
-flags** — so a project with `[agent] spec = "my_agent.py:graph"` in its
-`deepagents.toml` needs no VS Code setting at all. Inspect the resolved values:
-
-```bash
-deepagent-vscode-sidecar --show-config
-```
-
-Your agent is any LangGraph `CompiledGraph` (e.g. from `deepagents`), exported
-under the name in the spec:
-
-```python
-# my_agent.py
-from deepagents import create_deep_agent
-graph = create_deep_agent(...)   # -> deepagent.agentSpec = "my_agent.py:graph"
-```
-
-## Usage
-
-Open the chat panel and start a message with `@deepagent`:
-
-```
-@deepagent summarize the failing tests in this repo and propose a fix
-```
-
-The extension streams the agent's content, tool calls, reasoning, and todo
-updates into the chat response.
-
-## Sidecar protocol
-
-The extension talks to the sidecar over newline-delimited JSON. You can drive it
-directly for testing:
-
-```bash
-DEEPAGENT_AGENT_SPEC=./my_agent.py:graph python -m deepagent_vscode
-
-# or with no agent and no API key at all:
-python -m deepagent_vscode --demo
-```
-
-**Commands** (client → sidecar), one JSON object per line:
-
-```jsonc
-{"type": "message",  "session_id": "s1", "content": "hello"}
-{"type": "decision", "session_id": "s1", "decisions": [{"type": "approve"}]}
-{"type": "shutdown"}
-```
-
-**Events** (sidecar → client) — the `event.to_dict()` shapes from
-`langgraph-stream-parser`, plus a few protocol frames:
-
-```jsonc
-{"type": "ready"}                          // emitted once at startup
-{"type": "ack", "ref": "message"}          // command accepted
-{"type": "content", "content": "..."}      // assistant text
-{"type": "tool_start", "name": "...", ...} // tool call
-{"type": "tool_end", "name": "...", ...}   // tool result
-{"type": "interrupt", "action_requests": [...]}  // human-in-the-loop
-{"type": "complete"}                       // turn finished
-{"type": "turn_end", "session_id": "s1"}
-```
-
-## Development
-
-```bash
-# Sidecar
-pip install -e ".[dev]"
-pytest
-
-# Extension
-cd extension
-npm install
-npm run compile
-```
-
-## License
-
-MIT

deepagent_vscode-0.2.0/assets/header.svg

@@ -1,81 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1280" height="340" viewBox="0 0 1280 340" role="img" aria-label="deepagent-vscode — chat with your LangGraph and deepagents agent inside VS Code">
-  <defs>
-    <linearGradient id="bg" x1="0" y1="0" x2="1" y2="1">
-      <stop offset="0" stop-color="#0B1221"/>
-      <stop offset="1" stop-color="#0E1B2E"/>
-    </linearGradient>
-    <linearGradient id="accent" x1="0" y1="0" x2="1" y2="0">
-      <stop offset="0" stop-color="#2F9BFF"/>
-      <stop offset="1" stop-color="#34D6C8"/>
-    </linearGradient>
-    <radialGradient id="glow" cx="0.82" cy="0.15" r="0.6">
-      <stop offset="0" stop-color="#2F9BFF" stop-opacity="0.22"/>
-      <stop offset="1" stop-color="#2F9BFF" stop-opacity="0"/>
-    </radialGradient>
-    <filter id="soft" x="-20%" y="-20%" width="140%" height="140%">
-      <feDropShadow dx="0" dy="6" stdDeviation="12" flood-color="#000000" flood-opacity="0.35"/>
-    </filter>
-  </defs>
-
-  <!-- backdrop -->
-  <rect width="1280" height="340" rx="20" fill="url(#bg)"/>
-  <rect width="1280" height="340" rx="20" fill="url(#glow)"/>
-  <rect x="1" y="1" width="1278" height="338" rx="19" fill="none" stroke="#21314A" stroke-width="1.5"/>
-
-  <!-- ===== left: identity ===== -->
-  <!-- @deepagent pill -->
-  <g transform="translate(72,66)">
-    <rect width="158" height="34" rx="17" fill="#0F2C3A" stroke="url(#accent)" stroke-width="1.5"/>
-    <circle cx="22" cy="17" r="5" fill="url(#accent)"/>
-    <text x="40" y="23" font-family="'SF Mono','JetBrains Mono','Consolas',monospace" font-size="16" fill="#9FE9DF">@deepagent</text>
-  </g>
-
-  <!-- title -->
-  <text x="70" y="178" font-family="'SF Mono','JetBrains Mono','Consolas',monospace" font-size="62" font-weight="700" fill="#F2F6FC" letter-spacing="-1">deepagent<tspan fill="url(#accent)">-vscode</tspan></text>
-
-  <!-- tagline -->
-  <text x="72" y="224" font-family="'Segoe UI',Helvetica,Arial,sans-serif" font-size="22" fill="#9DB2C8">Chat with your LangGraph &#183; deepagents agent</text>
-  <text x="72" y="254" font-family="'Segoe UI',Helvetica,Arial,sans-serif" font-size="22" fill="#9DB2C8">inside VS Code &#8212; right next to Copilot.</text>
-
-  <!-- footer chips -->
-  <g font-family="'SF Mono','JetBrains Mono','Consolas',monospace" font-size="13" fill="#6F8298">
-    <text x="72" y="300">chat participant</text>
-    <text x="214" y="300" fill="#34506A">&#8226;</text>
-    <text x="236" y="300">python sidecar</text>
-    <text x="372" y="300" fill="#34506A">&#8226;</text>
-    <text x="394" y="300">langgraph-stream-parser</text>
-  </g>
-
-  <!-- ===== right: chat-panel mock ===== -->
-  <g transform="translate(812,70)" filter="url(#soft)">
-    <rect width="396" height="200" rx="14" fill="#0F2235" stroke="#23415C" stroke-width="1.5"/>
-    <!-- title bar -->
-    <rect width="396" height="38" rx="14" fill="#13314A"/>
-    <rect y="24" width="396" height="14" fill="#13314A"/>
-    <circle cx="24" cy="19" r="5" fill="#E06C75"/>
-    <circle cx="44" cy="19" r="5" fill="#E5C07B"/>
-    <circle cx="64" cy="19" r="5" fill="#56C28B"/>
-    <text x="340" y="24" font-family="'SF Mono','Consolas',monospace" font-size="12" fill="#6F8298">CHAT</text>
-
-    <!-- user bubble (right) -->
-    <g transform="translate(150,58)">
-      <rect width="220" height="34" rx="10" fill="#1C3A52"/>
-      <text x="16" y="22" font-family="'Segoe UI',Arial,sans-serif" font-size="13" fill="#C7D6E6">fix the failing test</text>
-    </g>
-
-    <!-- assistant: @deepagent -->
-    <g transform="translate(20,108)">
-      <circle cx="9" cy="9" r="8" fill="url(#accent)"/>
-      <text x="28" y="13" font-family="'SF Mono','Consolas',monospace" font-size="13" fill="#9FE9DF">@deepagent</text>
-      <rect x="0" y="28" width="300" height="9" rx="4.5" fill="#27425C"/>
-      <rect x="0" y="46" width="356" height="9" rx="4.5" fill="#27425C"/>
-      <rect x="0" y="64" width="210" height="9" rx="4.5" fill="#27425C"/>
-      <!-- tool chip -->
-      <g transform="translate(0,82)">
-        <rect width="150" height="22" rx="6" fill="#0C2A22" stroke="#34D6C8" stroke-width="1"/>
-        <circle cx="15" cy="11" r="4" fill="#34D6C8"/>
-        <text x="28" y="15" font-family="'SF Mono','Consolas',monospace" font-size="11" fill="#7FE3D6">run_tests &#10003;</text>
-      </g>
-    </g>
-  </g>
-</svg>

deepagent_vscode-0.2.0/deepagent_vscode/__init__.py

@@ -1,11 +0,0 @@
-"""deepagent-vscode — Python stdio sidecar for the VS Code chat extension.
-
-The extension spawns ``python -m deepagent_vscode`` (or the
-``deepagent-vscode-sidecar`` console script); the sidecar bridges a
-LangGraph/deepagents agent to the chat participant over newline-delimited JSON.
-"""
-from .sidecar import main, run
-
-__version__ = "0.1.0"
-
-__all__ = ["main", "run", "__version__"]

deepagent_vscode-0.2.0/deepagent_vscode/__main__.py

@@ -1,3 +0,0 @@
-from .sidecar import main
-
-raise SystemExit(main())

deepagent_vscode-0.2.0/deepagent_vscode/sidecar.py

@@ -1,189 +0,0 @@
-"""stdio sidecar bridging a LangGraph agent to the deepagent-vscode extension.
-
-Reads newline-delimited JSON commands on stdin, runs the agent through
-``langgraph-stream-parser``, and writes newline-delimited JSON events on
-stdout. The events are exactly ``event.to_dict()`` shapes — the same wire
-vocabulary every other deep-agent surface (FastAPI WebSocket/SSE, Jupyter, CLI)
-emits — so the TS extension's dispatcher renders them the same way.
-
-Commands (client -> sidecar), one JSON object per line:
-    {"type": "message",  "session_id": "s1", "content": "..."}
-    {"type": "decision", "session_id": "s1", "decisions": [{"type": "approve"}]}
-    {"type": "shutdown"}
-
-Events (sidecar -> client), one JSON object per line:
-    {"type": "ready"}                          # once, at startup
-    {"type": "ack", "ref": "message|decision"} # command accepted
-    <event_to_dict(...)>                       # content/tool_start/tool_end/
-                                               # reasoning/extraction/interrupt
-    {"type": "complete"} | {"type": "error", "error": "..."}
-    {"type": "turn_end", "session_id": "s1"}   # one turn finished
-"""
-from __future__ import annotations
-
-import json
-from typing import Any, Callable, Iterable, TextIO
-
-from langgraph_stream_parser import (
-    StreamParser,
-    create_resume_input,
-    event_to_dict,
-    load_agent_spec,
-    prepare_agent_input,
-)
-
-DEFAULT_STREAM_MODE = ["updates", "messages"]
-DEFAULT_MAX_RESULT_LEN = 50_000
-
-
-def run(
-    graph: Any,
-    stdin: Iterable[str],
-    stdout: TextIO,
-    *,
-    stream_mode: str | list[str] = DEFAULT_STREAM_MODE,
-    max_result_len: int = DEFAULT_MAX_RESULT_LEN,
-) -> None:
-    """Drive the command/event loop over the given streams.
-
-    Factored out from ``main`` so it can be tested with in-memory streams and
-    a fake graph. ``stdin`` is any line iterable; ``stdout`` needs ``write``.
-    """
-    mode = list(stream_mode) if isinstance(stream_mode, tuple) else stream_mode
-
-    def emit(obj: dict[str, Any]) -> None:
-        stdout.write(json.dumps(obj) + "\n")
-        stdout.flush()
-
-    emit({"type": "ready"})
-
-    for raw in stdin:
-        line = raw.strip()
-        if not line:
-            continue
-        try:
-            cmd = json.loads(line)
-        except json.JSONDecodeError as e:
-            emit({"type": "error", "error": f"invalid JSON: {e}"})
-            continue
-
-        ctype = cmd.get("type")
-        if ctype == "shutdown":
-            break
-
-        session_id = cmd.get("session_id", "default")
-        config = {"configurable": {"thread_id": session_id}}
-
-        if ctype == "message":
-            content = cmd.get("content", "")
-            if not content:
-                emit({"type": "error", "error": "message requires 'content'"})
-                continue
-            emit({"type": "ack", "ref": "message"})
-            input_data = prepare_agent_input(message=content)
-        elif ctype == "decision":
-            decisions = cmd.get("decisions")
-            if not isinstance(decisions, list):
-                emit({"type": "error", "error": "decision requires 'decisions' list"})
-                continue
-            emit({"type": "ack", "ref": "decision"})
-            input_data = create_resume_input(decisions=decisions)
-        else:
-            emit({"type": "error", "error": f"unknown command type: {ctype!r}"})
-            continue
-
-        _run_turn(graph, input_data, config, mode, max_result_len, emit)
-        emit({"type": "turn_end", "session_id": session_id})
-
-
-def _run_turn(
-    graph: Any,
-    input_data: Any,
-    config: dict[str, Any],
-    stream_mode: str | list[str],
-    max_result_len: int,
-    emit: Callable[[dict[str, Any]], None],
-) -> None:
-    """Stream one turn; the parser emits the terminal complete/error event."""
-    parser = StreamParser(stream_mode=stream_mode)
-    try:
-        stream = graph.stream(input_data, config=config, stream_mode=stream_mode)
-        for event in parser.parse(stream):
-            emit(event_to_dict(event, max_result_len=max_result_len))
-    except Exception as exc:  # noqa: BLE001 — surfaced to the client as an event
-        emit({"type": "error", "error": f"{type(exc).__name__}: {exc}"})
-
-
-# The keyless echo agent shipped with the shared core — see `--demo`.
-DEMO_AGENT_SPEC = "langgraph_stream_parser.demo.stub:graph"
-
-
-def main(argv: list[str] | None = None) -> int:
-    import argparse
-    import os
-    import sys
-
-    from langgraph_stream_parser.host import HostConfig
-
-    parser = argparse.ArgumentParser(prog="deepagent-vscode-sidecar")
-    parser.add_argument(
-        "--agent",
-        default=None,
-        help="Agent spec 'path.py:var' or 'module:var' "
-        "(overrides DEEPAGENT_AGENT_SPEC / deepagents.toml [agent].spec).",
-    )
-    parser.add_argument(
-        "--workspace",
-        default=None,
-        help="Workspace root (overrides DEEPAGENT_WORKSPACE_ROOT / deepagents.toml).",
-    )
-    parser.add_argument(
-        "--demo",
-        action="store_true",
-        help="Run with the built-in keyless demo agent — no API key needed.",
-    )
-    parser.add_argument(
-        "--show-config",
-        action="store_true",
-        help="Print the resolved configuration (defaults < deepagents.toml < env < CLI) and exit.",
-    )
-    args = parser.parse_args(argv)
-
-    # Same resolution chain as every other deep-agent surface:
-    # defaults < deepagents.toml < DEEPAGENT_* env < CLI flags.
-    cfg = HostConfig.resolve(
-        overrides={"agent_spec": args.agent, "workspace_root": args.workspace}
-    )
-
-    if args.show_config:
-        print(cfg.describe())
-        return 0
-
-    def fail(msg: str) -> int:
-        sys.stdout.write(json.dumps({"type": "error", "error": msg}) + "\n")
-        sys.stdout.flush()
-        return 1
-
-    spec = cfg.agent_spec
-    if args.demo:
-        if args.agent:
-            return fail("--demo and --agent are mutually exclusive")
-        spec = DEMO_AGENT_SPEC
-    if not spec:
-        return fail(
-            "no agent spec (pass --agent or --demo, set DEEPAGENT_AGENT_SPEC, "
-            "or set [agent].spec in deepagents.toml)"
-        )
-
-    os.environ.setdefault("DEEPAGENT_WORKSPACE_ROOT", str(cfg.workspace_root))
-    try:
-        graph = load_agent_spec(spec)
-    except Exception as exc:  # noqa: BLE001
-        return fail(f"failed to load agent {spec!r}: {type(exc).__name__}: {exc}")
-
-    run(graph, sys.stdin, sys.stdout)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

deepagent_vscode-0.2.0/extension/package-lock.json

@@ -1,58 +0,0 @@
-{
-  "name": "deepagent-vscode",
-  "version": "0.1.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "deepagent-vscode",
-      "version": "0.1.0",
-      "devDependencies": {
-        "@types/node": "^20.0.0",
-        "@types/vscode": "^1.95.0",
-        "typescript": "^5.4.0"
-      },
-      "engines": {
-        "vscode": "^1.95.0"
-      }
-    },
-    "node_modules/@types/node": {
-      "version": "20.19.41",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.41.tgz",
-      "integrity": "sha512-ECymXOukMnOoVkC2bb1Vc/w/836DXncOg5m8Xj1RH7xSHZJWNYY6Zh7EH477vcnD5egKNNfy2RpNOmuChhFPgQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~6.21.0"
-      }
-    },
-    "node_modules/@types/vscode": {
-      "version": "1.120.0",
-      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.120.0.tgz",
-      "integrity": "sha512-feaT4Rst+FkTch5zz/ZbNCxoIvo55YU80Be2kiL7OJcod4+CUYf2lUBPdIJzozNnSEMq1VRTGrWEcCGFB3fBmA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/typescript": {
-      "version": "5.9.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
-      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
-      }
-    },
-    "node_modules/undici-types": {
-      "version": "6.21.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
-      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
-      "dev": true,
-      "license": "MIT"
-    }
-  }
-}

deepagent_vscode-0.2.0/extension/package.json

@@ -1,49 +0,0 @@
-{
-  "name": "deepagent-vscode",
-  "displayName": "Deep Agent",
-  "description": "Chat with your LangGraph / deepagents agent from VS Code, alongside Copilot.",
-  "version": "0.2.0",
-  "publisher": "dkedar7",
-  "engines": {
-    "vscode": "^1.95.0"
-  },
-  "categories": ["AI", "Chat", "Other"],
-  "activationEvents": [],
-  "main": "./dist/extension.js",
-  "contributes": {
-    "chatParticipants": [
-      {
-        "id": "deepagent.agent",
-        "name": "deepagent",
-        "fullName": "Deep Agent",
-        "description": "Run your LangGraph/deepagents agent",
-        "isSticky": true
-      }
-    ],
-    "configuration": {
-      "title": "Deep Agent",
-      "properties": {
-        "deepagent.agentSpec": {
-          "type": "string",
-          "default": "",
-          "description": "Agent spec 'path/to/agent.py:graph' or 'module:graph' to run. Leave empty to fall back to DEEPAGENT_AGENT_SPEC or the project's deepagents.toml."
-        },
-        "deepagent.pythonPath": {
-          "type": "string",
-          "default": "python",
-          "description": "Python interpreter used to launch the deepagent-vscode sidecar (must have deepagent-vscode installed)."
-        }
-      }
-    }
-  },
-  "scripts": {
-    "compile": "tsc -p ./",
-    "watch": "tsc -watch -p ./",
-    "vscode:prepublish": "npm run compile"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/vscode": "^1.95.0",
-    "typescript": "^5.4.0"
-  }
-}

deepagent_vscode-0.2.0/extension/src/extension.ts

@@ -1,161 +0,0 @@
-import * as vscode from 'vscode';
-import { spawn, ChildProcess } from 'child_process';
-import * as readline from 'readline';
-
-/**
- * Deep Agent VS Code chat participant.
- *
- * Registers `@deepagent` in the chat panel (alongside Copilot) and bridges each
- * turn to the Python `deepagent-vscode` sidecar over stdio. The sidecar emits
- * newline-delimited JSON events — the langgraph-stream-parser `event.to_dict()`
- * wire vocabulary — which the dispatcher below maps onto the chat response.
- */
-export function activate(context: vscode.ExtensionContext) {
-  const participant = vscode.chat.createChatParticipant('deepagent.agent', handler);
-  participant.iconPath = new vscode.ThemeIcon('robot');
-  context.subscriptions.push(participant);
-}
-
-export function deactivate() {}
-
-interface AgentEvent {
-  type: string;
-  [key: string]: unknown;
-}
-
-async function handler(
-  request: vscode.ChatRequest,
-  _context: vscode.ChatContext,
-  stream: vscode.ChatResponseStream,
-  token: vscode.CancellationToken,
-): Promise<void> {
-  const config = vscode.workspace.getConfiguration('deepagent');
-  const agentSpec = config.get<string>('agentSpec') ?? '';
-  const python = config.get<string>('pythonPath') || 'python';
-
-  const workspace =
-    vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? process.cwd();
-
-  // When the setting is empty, spawn without --agent and let the sidecar
-  // resolve the family-standard chain (deepagents.toml < DEEPAGENT_* env).
-  // If nothing resolves anywhere, the sidecar emits a clean `error` event
-  // that the dispatcher renders in the chat.
-  const args = ['-m', 'deepagent_vscode', '--workspace', workspace];
-  if (agentSpec) {
-    args.push('--agent', agentSpec);
-  }
-
-  const proc = spawn(python, args, {
-    // cwd anchors the sidecar's deepagents.toml walk-up at the workspace.
-    cwd: workspace,
-    env: { ...process.env, DEEPAGENT_WORKSPACE_ROOT: workspace },
-  });
-
-  token.onCancellationRequested(() => proc.kill());
-
-  try {
-    await runTurn(proc, request.prompt, stream);
-  } catch (err) {
-    stream.markdown(`\n\n❌ ${err instanceof Error ? err.message : String(err)}`);
-  } finally {
-    proc.kill();
-  }
-}
-
-/**
- * Send one user message to the sidecar and pump its events into the chat
- * stream until the turn ends.
- */
-function runTurn(
-  proc: ChildProcess,
-  prompt: string,
-  stream: vscode.ChatResponseStream,
-): Promise<void> {
-  return new Promise<void>((resolve, reject) => {
-    if (!proc.stdout || !proc.stdin) {
-      reject(new Error('sidecar has no stdio pipes'));
-      return;
-    }
-
-    const rl = readline.createInterface({ input: proc.stdout });
-    let started = false;
-
-    rl.on('line', (line: string) => {
-      const text = line.trim();
-      if (!text) return;
-      let event: AgentEvent;
-      try {
-        event = JSON.parse(text) as AgentEvent;
-      } catch {
-        return; // ignore non-JSON noise
-      }
-
-      // Send the message once the sidecar reports it's ready.
-      if (event.type === 'ready' && !started) {
-        started = true;
-        proc.stdin!.write(
-          JSON.stringify({ type: 'message', session_id: 'vscode', content: prompt }) + '\n',
-        );
-        return;
-      }
-
-      dispatch(event, stream);
-
-      if (event.type === 'turn_end') {
-        rl.close();
-        resolve();
-      }
-    });
-
-    proc.on('error', reject);
-    proc.on('exit', () => resolve());
-  });
-}
-
-/** Map one sidecar event onto the chat response stream. */
-function dispatch(event: AgentEvent, stream: vscode.ChatResponseStream): void {
-  switch (event.type) {
-    case 'content':
-      stream.markdown(String(event.content ?? ''));
-      break;
-    case 'reasoning':
-      stream.markdown(`\n\n*${String(event.content ?? '')}*\n\n`);
-      break;
-    case 'tool_start':
-      stream.progress(`Running \`${String(event.name ?? 'tool')}\`…`);
-      break;
-    case 'tool_end': {
-      const status = event.status === 'error' ? '❌' : '✓';
-      stream.markdown(`\n\n${status} \`${String(event.name ?? 'tool')}\`\n`);
-      break;
-    }
-    case 'extraction':
-      if (event.extracted_type === 'todos' && Array.isArray(event.data)) {
-        stream.markdown('\n\n**Tasks**\n');
-        for (const item of event.data as Array<Record<string, unknown>>) {
-          const done = item.status === 'completed';
-          const content = String(item.content ?? item.task ?? '');
-          stream.markdown(`- ${done ? '[x]' : '[ ]'} ${content}\n`);
-        }
-      }
-      break;
-    case 'interrupt': {
-      // HITL: v0 surfaces the requested action. The decision round-trip
-      // (sending {"type":"decision",...} back to the sidecar) is the next
-      // increment — it needs a confirmation affordance in the chat UI.
-      const actions = (event.action_requests as Array<Record<string, unknown>>) ?? [];
-      const tool = actions[0]?.tool ?? 'an action';
-      stream.markdown(
-        `\n\n⚠️ The agent wants to run **${String(tool)}** and is waiting for ` +
-          'approval. Interactive approval is not wired up yet in this build.\n',
-      );
-      break;
-    }
-    case 'error':
-      stream.markdown(`\n\n❌ ${String(event.error ?? 'unknown error')}\n`);
-      break;
-    // ready / ack / complete / turn_end / usage: no direct UI output.
-    default:
-      break;
-  }
-}

deepagent_vscode-0.2.0/extension/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "target": "ES2020",
-    "outDir": "dist",
-    "lib": ["ES2020"],
-    "sourceMap": true,
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}

deepagent_vscode-0.2.0/pyproject.toml

@@ -1,36 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "deepagent-vscode"
-version = "0.2.0"
-description = "Python stdio sidecar bridging LangGraph/deepagents agents to the deepagent-vscode chat extension"
-license = "MIT"
-requires-python = ">=3.11"
-authors = [
-    {name = "Kedar Dabhadkar"}
-]
-keywords = ["langgraph", "deepagents", "vscode", "agents", "ai"]
-dependencies = [
-    "langgraph-stream-parser>=0.2.2,<0.3",
-]
-
-[project.optional-dependencies]
-demo = [
-    "deepagents>=0.3",
-]
-dev = [
-    "pytest>=8",
-    "langgraph>=1.1.0",
-    "langchain-core>=1.4.0",
-]
-
-[project.scripts]
-deepagent-vscode-sidecar = "deepagent_vscode.sidecar:main"
-
-[tool.hatch.build.targets.wheel]
-packages = ["deepagent_vscode"]
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]

deepagent_vscode-0.2.0/tests/test_sidecar.py

@@ -1,215 +0,0 @@
-"""Tests for the stdio sidecar command/event loop."""
-import io
-import json
-from dataclasses import dataclass
-from typing import Any
-
-from langchain_core.messages import AIMessage, ToolMessage
-
-from deepagent_vscode.sidecar import main, run
-
-
-# ── Fakes / fixtures ─────────────────────────────────────────────────
-
-
-class FakeGraph:
-    """Sync LangGraph-ish fake yielding canned single-mode 'updates' chunks."""
-
-    def __init__(self, chunks_per_call: list[list[Any]]):
-        self._chunks = chunks_per_call
-        self._i = 0
-        self.calls: list[dict] = []
-
-    def stream(self, input_data, config=None, stream_mode="updates"):
-        self.calls.append({"input": input_data, "config": config, "stream_mode": stream_mode})
-        chunks = self._chunks[self._i]
-        self._i += 1
-        for c in chunks:
-            yield c
-
-
-@dataclass
-class MockInterrupt:
-    value: Any
-    resumable: bool = True
-
-
-CONTENT = {"agent": {"messages": [AIMessage(content="Hello there")]}}
-TOOLCALL = {"agent": {"messages": [AIMessage(
-    content="", tool_calls=[{"id": "c1", "name": "search", "args": {"q": "x"}}],
-)]}}
-TOOLRESULT = {"tools": {"messages": [ToolMessage(
-    content="result ok", name="search", tool_call_id="c1",
-)]}}
-INTERRUPT = {"__interrupt__": (MockInterrupt(value={
-    "action_requests": [{"name": "bash", "args": {"command": "ls"}, "tool_call_id": "c1"}],
-    "review_configs": [{"allowed_decisions": ["approve", "reject"]}],
-}),)}
-
-
-def drive(graph, commands, **kw):
-    """Feed JSON commands through run() and return parsed event dicts."""
-    stdin = io.StringIO("".join(json.dumps(c) + "\n" for c in commands))
-    stdout = io.StringIO()
-    run(graph, stdin, stdout, stream_mode="updates", **kw)
-    return [json.loads(line) for line in stdout.getvalue().splitlines() if line.strip()]
-
-
-# ── Tests ────────────────────────────────────────────────────────────
-
-
-def test_ready_is_first_event():
-    events = drive(FakeGraph([]), [{"type": "shutdown"}])
-    assert events[0] == {"type": "ready"}
-
-
-def test_message_turn_emits_content_and_terminals():
-    graph = FakeGraph([[CONTENT]])
-    events = drive(graph, [
-        {"type": "message", "session_id": "s", "content": "hi"},
-        {"type": "shutdown"},
-    ])
-    types = [e["type"] for e in events]
-    assert types[0] == "ready"
-    assert {"type": "ack", "ref": "message"} in events
-    assert "content" in types
-    assert "complete" in types
-    assert any(e["type"] == "turn_end" and e["session_id"] == "s" for e in events)
-    # thread_id wired from session_id
-    assert graph.calls[0]["config"] == {"configurable": {"thread_id": "s"}}
-
-
-def test_tool_lifecycle():
-    graph = FakeGraph([[TOOLCALL, TOOLRESULT]])
-    events = drive(graph, [
-        {"type": "message", "session_id": "s", "content": "search"},
-        {"type": "shutdown"},
-    ])
-    types = [e["type"] for e in events]
-    assert "tool_start" in types
-    assert "tool_end" in types
-
-
-def test_interrupt_then_decision_resumes():
-    graph = FakeGraph([[TOOLCALL, INTERRUPT], [TOOLRESULT]])
-    events = drive(graph, [
-        {"type": "message", "session_id": "s", "content": "run it"},
-        {"type": "decision", "session_id": "s", "decisions": [{"type": "approve"}]},
-        {"type": "shutdown"},
-    ])
-    types = [e["type"] for e in events]
-    assert "interrupt" in types
-    assert {"type": "ack", "ref": "decision"} in events
-    assert "tool_end" in types
-    # interrupt action_requests normalized to a 'tool' key
-    interrupt = next(e for e in events if e["type"] == "interrupt")
-    assert interrupt["action_requests"][0]["tool"] == "bash"
-    # second call resumes with a Command
-    from langgraph.types import Command
-    assert isinstance(graph.calls[1]["input"], Command)
-
-
-def test_invalid_json_reported():
-    stdin = io.StringIO("not json\n")
-    stdout = io.StringIO()
-    run(FakeGraph([]), stdin, stdout, stream_mode="updates")
-    events = [json.loads(line) for line in stdout.getvalue().splitlines() if line.strip()]
-    assert any(e["type"] == "error" and "invalid JSON" in e["error"] for e in events)
-
-
-# ── main(): config resolution + --demo / --show-config ───────────────
-
-
-def _isolate_config(monkeypatch, tmp_path):
-    """Point cwd + the global config home at an empty tmp dir and strip
-    DEEPAGENT_* env so main() resolves from pure defaults."""
-    monkeypatch.chdir(tmp_path)
-    monkeypatch.setenv("DEEPAGENTS_CONFIG_HOME", str(tmp_path))
-    for var in ("DEEPAGENT_AGENT_SPEC", "DEEPAGENT_WORKSPACE_ROOT"):
-        monkeypatch.delenv(var, raising=False)
-
-
-def test_main_show_config(monkeypatch, tmp_path, capsys):
-    _isolate_config(monkeypatch, tmp_path)
-    assert main(["--show-config"]) == 0
-    assert "DEEPAGENT_AGENT_SPEC" in capsys.readouterr().out
-
-
-def test_main_no_spec_emits_error(monkeypatch, tmp_path, capsys):
-    _isolate_config(monkeypatch, tmp_path)
-    assert main([]) == 1
-    err = json.loads(capsys.readouterr().out.strip())
-    assert err["type"] == "error"
-    assert "deepagents.toml" in err["error"]
-
-
-def test_main_demo_conflicts_with_agent(monkeypatch, tmp_path, capsys):
-    _isolate_config(monkeypatch, tmp_path)
-    assert main(["--demo", "--agent", "x.py:g"]) == 1
-    err = json.loads(capsys.readouterr().out.strip())
-    assert "mutually exclusive" in err["error"]
-
-
-def test_main_toml_supplies_agent_spec(monkeypatch, tmp_path, capsys):
-    """The deepagents.toml resolver is actually wired in: [agent].spec from a
-    project file reaches load_agent_spec with no flags or env."""
-    _isolate_config(monkeypatch, tmp_path)
-    (tmp_path / "deepagents.toml").write_text(
-        '[agent]\nspec = "langgraph_stream_parser.demo.stub:graph"\n'
-    )
-    monkeypatch.setattr(
-        "sys.stdin", io.StringIO(json.dumps({"type": "shutdown"}) + "\n")
-    )
-    assert main([]) == 0
-    events = [json.loads(line) for line in capsys.readouterr().out.splitlines() if line.strip()]
-    assert events[0] == {"type": "ready"}
-
-
-def test_main_demo_end_to_end(monkeypatch, tmp_path, capsys):
-    """--demo answers a real message turn through the stub agent — no keys."""
-    _isolate_config(monkeypatch, tmp_path)
-    commands = (
-        json.dumps({"type": "message", "session_id": "s", "content": "hi demo"})
-        + "\n"
-        + json.dumps({"type": "shutdown"})
-        + "\n"
-    )
-    monkeypatch.setattr("sys.stdin", io.StringIO(commands))
-    assert main(["--demo"]) == 0
-    events = [json.loads(line) for line in capsys.readouterr().out.splitlines() if line.strip()]
-    types = [e["type"] for e in events]
-    assert "ready" in types and "complete" in types and "turn_end" in types
-    content = "".join(e.get("content", "") for e in events if e["type"] == "content")
-    assert "hi demo" in content
-
-
-def test_unknown_command_reported():
-    events = drive(FakeGraph([]), [{"type": "nope"}, {"type": "shutdown"}])
-    assert any(e["type"] == "error" and "unknown command" in e["error"] for e in events)
-
-
-def test_empty_message_reported():
-    events = drive(FakeGraph([]), [
-        {"type": "message", "content": ""},
-        {"type": "shutdown"},
-    ])
-    assert any(e["type"] == "error" and "content" in e["error"] for e in events)
-
-
-def test_decision_without_list_reported():
-    events = drive(FakeGraph([]), [{"type": "decision"}, {"type": "shutdown"}])
-    assert any(e["type"] == "error" and "decisions" in e["error"] for e in events)
-
-
-def test_graph_error_surfaced():
-    class BoomGraph:
-        def stream(self, *a, **k):
-            raise RuntimeError("kaboom")
-            yield  # pragma: no cover
-
-    events = drive(BoomGraph(), [
-        {"type": "message", "content": "go"},
-        {"type": "shutdown"},
-    ])
-    err = [e for e in events if e["type"] == "error"]
-    assert err and "kaboom" in err[-1]["error"]