langchain-quickjs 0.3.0__tar.gz → 0.3.2__tar.gz

{langchain_quickjs-0.3.0 → langchain_quickjs-0.3.2}/.gitignore

@@ -251,3 +251,6 @@ CLAUDE.md
 libs/cli/frontend/node_modules/
 libs/cli/frontend/dist/
 node_modules/
+
+# Generated at build time by libs/code/hatch_build.py (stamps the release commit)
+libs/code/deepagents_code/_build_info.py

{langchain_quickjs-0.3.0 → langchain_quickjs-0.3.2}/CHANGELOG.md

@@ -2,17 +2,34 @@
 
 # Changelog
 
-## [0.3.0](https://github.com/langchain-ai/deepagents/compare/langchain-quickjs==0.2.0...langchain-quickjs==0.3.0) (2026-06-18)
+## [0.3.2](https://github.com/langchain-ai/deepagents/compare/langchain-quickjs==0.3.1...langchain-quickjs==0.3.2) (2026-06-25)
+
+### Features
+
+* Dynamic subagents UI ([#4221](https://github.com/langchain-ai/deepagents/issues/4221)) ([10bcba2](https://github.com/langchain-ai/deepagents/commit/10bcba25600e51aba135f170b34aa6315c0f53d6))
+
+### Bug Fixes
 
+* Ensure top-level title on subagent response schemas ([#4155](https://github.com/langchain-ai/deepagents/issues/4155)) ([08f917e](https://github.com/langchain-ai/deepagents/commit/08f917eea79513e7e894731f884e738c2d30383f))
+* Normalize nested `undefined` tool args ([#3935](https://github.com/langchain-ai/deepagents/issues/3935)) ([1b461a0](https://github.com/langchain-ai/deepagents/commit/1b461a0d6c6a7a6d323db18505596fcce4326b92))
+
+## [0.3.1](https://github.com/langchain-ai/deepagents/compare/langchain-quickjs==0.3.0...langchain-quickjs==0.3.1) (2026-06-22)
+
+### Bug Fixes
+
+* Persist top-level JS declarations across evals ([#4147](https://github.com/langchain-ai/deepagents/issues/4147)) ([7574fea](https://github.com/langchain-ai/deepagents/commit/7574fea88b51c77f7afa8279c4f561d6ecb47e3f))
+* PTC tools in tools namespace are rendered without prepended `tools.` in system prompt and task as ptc duplicated task global ([#4075](https://github.com/langchain-ai/deepagents/issues/4075)) ([014a903](https://github.com/langchain-ai/deepagents/commit/014a9033af70b5b8b08ad2eb36f98590f5f1cca8))
+
+## [0.3.0](https://github.com/langchain-ai/deepagents/compare/langchain-quickjs==0.2.0...langchain-quickjs==0.3.0) (2026-06-18)
 
 ### ⚠ BREAKING CHANGES
 
-* **quickjs:** upgrade to 0.2.0 quickjs-rs ([#4067](https://github.com/langchain-ai/deepagents/issues/4067))
+* Upgrade to 0.2.0 quickjs-rs ([#4067](https://github.com/langchain-ai/deepagents/issues/4067))
 
 ### Features
 
-* **quickjs:** prompt tuning on task global ([#4066](https://github.com/langchain-ai/deepagents/issues/4066)) ([a47696f](https://github.com/langchain-ai/deepagents/commit/a47696f6d3e57eccb5ea19fb344305a7995ecc76))
-* **quickjs:** upgrade to 0.2.0 quickjs-rs ([#4067](https://github.com/langchain-ai/deepagents/issues/4067)) ([4ffea88](https://github.com/langchain-ai/deepagents/commit/4ffea88690418207b5e4fa800ee8c1abfa454bec))
+* Prompt tuning on task global ([#4066](https://github.com/langchain-ai/deepagents/issues/4066)) ([a47696f](https://github.com/langchain-ai/deepagents/commit/a47696f6d3e57eccb5ea19fb344305a7995ecc76))
+* Upgrade to 0.2.0 quickjs-rs ([#4067](https://github.com/langchain-ai/deepagents/issues/4067)) ([4ffea88](https://github.com/langchain-ai/deepagents/commit/4ffea88690418207b5e4fa800ee8c1abfa454bec))
 
 ## [0.2.0](https://github.com/langchain-ai/deepagents/compare/langchain-quickjs==0.1.4...langchain-quickjs==0.2.0) (2026-06-12)
 

{langchain_quickjs-0.3.0 → langchain_quickjs-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-quickjs
-Version: 0.3.0
+Version: 0.3.2
 Summary: JavaScript REPL middleware for deepagents
 Project-URL: Homepage, https://github.com/langchain-ai/deepagents/tree/main/libs/partners/quickjs
 Project-URL: Repository, https://github.com/langchain-ai/deepagents
@@ -16,11 +16,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <4.0,>=3.11
-Requires-Dist: deepagents<0.7.0,>=0.6.8
+Requires-Dist: bsdiff4<2.0.0,>=1.2.6
+Requires-Dist: deepagents<0.8.0,>=0.6.8
 Requires-Dist: langchain-core<2.0.0,>=1.4.7
 Requires-Dist: langchain<2.0.0,>=1.3.9
 Requires-Dist: langgraph<2.0.0,>=1.2.5
-Requires-Dist: quickjs-rs<0.3.0,>=0.2.0
+Requires-Dist: quickjs-rs<0.3.0,>=0.2.3
 Description-Content-Type: text/markdown
 
 # langchain-quickjs

langchain_quickjs-0.3.2/langchain_quickjs/__init__.py

@@ -0,0 +1,21 @@
+"""langchain-quickjs: persistent JS REPL middleware for agents."""
+
+from langchain_quickjs._ptc import PTCOption
+from langchain_quickjs._subagent import (
+    SUBAGENT_STREAM_EVENT_TYPE,
+    SubagentCompleteEvent,
+    SubagentErrorEvent,
+    SubagentStartEvent,
+    SubagentStreamEvent,
+)
+from langchain_quickjs.middleware import CodeInterpreterMiddleware
+
+__all__ = [
+    "SUBAGENT_STREAM_EVENT_TYPE",
+    "CodeInterpreterMiddleware",
+    "PTCOption",
+    "SubagentCompleteEvent",
+    "SubagentErrorEvent",
+    "SubagentStartEvent",
+    "SubagentStreamEvent",
+]

{langchain_quickjs-0.3.0 → langchain_quickjs-0.3.2}/langchain_quickjs/_format.py

@@ -17,7 +17,7 @@ _TRUNCATE_MARKER = "… [truncated {n} chars]"
 
 
 def format_handle(handle: Any) -> str:
-    """Describe a ``Handle`` value in REPL-style shorthand."""
+    """Describe a `Handle` value in REPL-style shorthand."""
     kind = handle.type_of
     if kind == "function":
         try:
@@ -60,7 +60,7 @@ def _format_jsvalue(value: Any) -> str:
 
 
 def _format_nested(value: Any) -> str:
-    """Like ``_format_jsvalue`` but quotes nested strings."""
+    """Like `_format_jsvalue` but quotes nested strings."""
     if isinstance(value, str):
         return f'"{value}"'
     return _format_jsvalue(value)
@@ -84,8 +84,8 @@ def coerce_tool_output(value: Any) -> str:
 
 
 # Scalar types the quickjs_rs binding marshals natively. Compound shapes
-# (``dict`` / ``list`` / ``tuple``) are walked recursively in
-# ``_coerce_for_marshal``; anything else becomes ``str(value)`` so the JS
+# (`dict` / `list` / `tuple`) are walked recursively in
+# `_coerce_for_marshal`; anything else becomes `str(value)` so the JS
 # side can still see a usable value.
 _NATIVE_JS_SCALARS = (str, bool, int, float, type(None))
 
@@ -93,18 +93,18 @@ _NATIVE_JS_SCALARS = (str, bool, int, float, type(None))
 def coerce_tool_output_for_ptc(value: Any) -> Any:
     """Coerce a tool result for the PTC bridge, preserving native types.
 
-    The quickjs_rs ``register`` bridge marshals Python primitives, ``list``,
-    and ``dict`` directly to native JS values, so the model can use them
-    without an explicit ``JSON.parse``. This helper unwraps LangChain's
-    ``ToolMessage`` / ``Command`` envelopes (matching ``coerce_tool_output``'s
+    The quickjs_rs `register` bridge marshals Python primitives, `list`,
+    and `dict` directly to native JS values, so the model can use them
+    without an explicit `JSON.parse`. This helper unwraps LangChain's
+    `ToolMessage` / `Command` envelopes (matching `coerce_tool_output`'s
     selection rules) and returns the underlying value typed.
 
     Compound returns are walked recursively: nested values that the binding
-    cannot marshal natively (``datetime``, Pydantic models, custom classes)
-    are stringified in place via ``str(value)`` so the surrounding object
+    cannot marshal natively (`datetime`, Pydantic models, custom classes)
+    are stringified in place via `str(value)` so the surrounding object
     structure remains navigable from JS. Cyclic structures hit Python's
     recursion limit and surface as a host error in the eval — same outcome
-    as ``json.dumps`` on a self-referencing dict.
+    as `json.dumps` on a self-referencing dict.
     """
     if isinstance(value, Command):
         return coerce_tool_output_for_ptc(_extract_command_content(value))
@@ -129,14 +129,14 @@ def _coerce_for_marshal(value: Any) -> Any:
         return [_coerce_for_marshal(v) for v in value]
     # Pydantic models are dumped to a plain dict so the JS side sees the
     # field shape its return-type signature advertises (rather than
-    # ``str(model)``). Nested models / datetimes are handled by recursion.
+    # `str(model)`). Nested models / datetimes are handled by recursion.
     if isinstance(value, BaseModel):
         return _coerce_for_marshal(value.model_dump())
     return str(value)
 
 
 def _extract_command_content(command: Command) -> Any:
-    """Return the trailing message content from a ``Command`` update, if any."""
+    """Return the trailing message content from a `Command` update, if any."""
     update = command.update
     if isinstance(update, dict):
         messages = update.get("messages")

{langchain_quickjs-0.3.0 → langchain_quickjs-0.3.2}/langchain_quickjs/_prompt.py

@@ -45,6 +45,7 @@ flow, and synthesis - in plain JavaScript.
 await task({
   description,      // full autonomous task prompt
   subagentType,     // configured subagent name
+  label,            // optional short UI label for this dispatch
   responseSchema,   // optional JSON Schema for structured output
 }); // -> Promise<unknown>
 ```
@@ -62,6 +63,10 @@ exploring, still pass its path and let the subagent read it; do not paste back
 what you read. Each dispatch is stateless from the caller's perspective; you
 cannot send follow-up messages to the same subagent run.
 
+`label` is optional: when provided, it is shown in the live progress UI
+instead of the default description-derived fallback. It is not sent to the
+subagent and does not affect execution.
+
 `responseSchema` is optional, but set it on any dispatch whose result feeds
 later code. A deterministic, typed shape is what lets you compose the next
 stage reliably — index it, sort it, compare fields, branch on it, merge it —
@@ -236,8 +241,10 @@ const findings = auditResults.flatMap((r) =>
   r.findings.map((f) => ({ ...f, file: r.file }))
 );
 const verified = await Promise.all(findings.map((f) =>
-  task({ description: "Verify this finding: " + f.evidence, subagentType: "verifier" })
-    .then((v) => ({ ...f, ...v }))
+  task({
+    description: "Verify this finding: " + f.evidence,
+    subagentType: "verifier",
+  }).then((v) => ({ ...f, ...v }))
 ));
 ```
 
@@ -260,10 +267,10 @@ def render_repl_system_prompt(
     mode: Literal["thread", "turn", "call"],
     ptc_attached: bool = False,
 ) -> str:
-    """Render the base REPL system prompt text for ``CodeInterpreterMiddleware``.
+    """Render the base REPL system prompt text for `CodeInterpreterMiddleware`.
 
-    ``ptc_attached`` controls the "external side effects" bullet: when host
-    tools are exposed as the ``tools.*`` namespace it points the model at the
+    `ptc_attached` controls the "external side effects" bullet: when host
+    tools are exposed as the `tools.*` namespace it points the model at the
     API reference; otherwise it states the REPL is pure computation.
     """
     if ptc_attached:
@@ -362,7 +369,7 @@ def render_eval_tool_description(*, mode: Literal["thread", "turn", "call"]) ->
 
 
 def to_camel_case(name: str) -> str:
-    """Convert ``snake_case`` / ``kebab-case`` → ``camelCase``."""
+    """Convert `snake_case` / `kebab-case` → `camelCase`."""
     return _CAMEL_SEP.sub(lambda m: m.group(1).upper(), name)
 
 
@@ -455,7 +462,7 @@ def _render_signature(
 ) -> str:
     return_clause = f"Promise<{return_type}>"
     default_signature = (
-        f"async function {fn_name}(input: Record<string, unknown>): {return_clause}"
+        f"tools.{fn_name}(input: Record<string, unknown>): {return_clause}"
     )
     if not schema or not isinstance(schema.get("properties"), dict):
         return default_signature
@@ -471,20 +478,20 @@ def _render_signature(
     body = "\n".join(fields) if fields else ""
     if not body:
         return default_signature
-    return f"async function {fn_name}(input: {{\n{body}\n}}): {return_clause}"
+    return f"tools.{fn_name}(input: {{\n{body}\n}}): {return_clause}"
 
 
 # Return types come from the tool's underlying function annotation. We feed
-# the annotation through ``pydantic.TypeAdapter`` to get a JSON Schema and
-# render it through the same ``_json_schema_to_ts`` we use for input args.
-# Compound shapes (TypedDict, BaseModel, recursive types) end up as ``$ref``
-# in the schema and currently render as ``unknown`` — same behaviour as
-# nested-model input args. Until that path resolves ``$ref`` / ``$defs``,
+# the annotation through `pydantic.TypeAdapter` to get a JSON Schema and
+# render it through the same `_json_schema_to_ts` we use for input args.
+# Compound shapes (TypedDict, BaseModel, recursive types) end up as `$ref`
+# in the schema and currently render as `unknown` — same behaviour as
+# nested-model input args. Until that path resolves `$ref` / `$defs`,
 # the simpler unified renderer is the right trade-off here.
 
 
 def _render_return_type(tool: BaseTool) -> str:
-    """Render the return annotation as a TS type, defaulting to ``unknown``."""
+    """Render the return annotation as a TS type, defaulting to `unknown`."""
     target = getattr(tool, "func", None) or getattr(tool, "coroutine", None)
     if target is None:
         return "unknown"

{langchain_quickjs-0.3.0 → langchain_quickjs-0.3.2}/langchain_quickjs/_ptc.py

@@ -1,8 +1,8 @@
-"""Programmatic tool calling (PTC) support for ``CodeInterpreterMiddleware``.
+"""Programmatic tool calling (PTC) support for `CodeInterpreterMiddleware`.
 
 PTC exposes the agent's LangChain tools inside the JavaScript REPL as
-``tools.<camelCaseName>(input)`` async functions. Instead of issuing
-N serial tool calls, the model writes one ``eval`` that loops / parallelises
+`tools.<camelCaseName>(input)` async functions. Instead of issuing
+N serial tool calls, the model writes one `eval` that loops / parallelises
 / chains tools in-code:
 
     const [a, b] = await Promise.all([
@@ -14,10 +14,10 @@ Two pieces live here:
 
 - filtering — turn the live agent toolset into the subset exposed to PTC
 - prompt rendering — render a short TS-ish API-reference block describing
-  each exposed tool, so the model knows the call shape
+    each exposed tool, so the model knows the call shape
 
 The host-function bridge that actually invokes each tool lives in
-``_repl.py`` next to the rest of the context wiring.
+`_repl.py` next to the rest of the context wiring.
 """
 
 from __future__ import annotations
@@ -34,6 +34,16 @@ if TYPE_CHECKING:
 
 PTCOption = list[str | BaseTool]
 
+_RESERVED_SUBAGENT_TASK_NAME = "task"
+
+_TASK_IN_PTC_MSG = (
+    "The subagent `task` tool cannot be exposed via `ptc`. It is always "
+    "available as the top-level `task()` global inside the REPL (with "
+    "`subagentType`, `label`, and `responseSchema` support); exposing it through "
+    "the `tools.*` namespace would create a second, conflicting dispatch path "
+    'that drops `responseSchema`. Remove "task" from `ptc`.'
+)
+
 
 def filter_tools_for_ptc(
     tools: Sequence[BaseTool],
@@ -41,23 +51,28 @@ def filter_tools_for_ptc(
     *,
     self_tool_name: str,
 ) -> list[BaseTool]:
-    """Return the subset of ``tools`` exposed inside the REPL.
+    """Return the subset of `tools` exposed inside the REPL.
 
-    ``self_tool_name`` is the REPL's own tool name; it is *always* excluded
-    to prevent the model from recursing ``tools.eval("tools.eval(...)")``.
+    `self_tool_name` is the REPL's own tool name; it is *always* excluded
+    to prevent the model from recursing `tools.eval("tools.eval(...)")`.
     If the model wants a nested eval, it can just write nested code in one
     call — that's the whole point of PTC.
 
-    ``config`` is allowlist-only:
+    `config` is allowlist-only:
 
-    - ``str`` entries: expose matching tool names from ``tools``.
-    - ``BaseTool`` entries: expose those tools directly (minus
-      ``self_tool_name``).
+    - `str` entries: expose matching tool names from `tools`.
+    - `BaseTool` entries: expose those tools directly (minus
+        `self_tool_name`).
 
-    Mixed lists are supported and merged. Explicit ``BaseTool`` entries
+    Mixed lists are supported and merged. Explicit `BaseTool` entries
     are included first, then name-matched agent tools are appended.
     Duplicate tool names are deduplicated.
 
+    The subagent `task` tool is reserved and may not appear in `config`
+    (by name or instance) — it is always available as the `task()` global,
+    so a `tools.task` PTC variant would be a conflicting, degraded duplicate.
+    A `"task"` entry raises `ValueError`.
+
     Warning:
         PTC tool calls execute through the REPL bridge and currently do
         not respect `interrupt_on` / HITL approval hooks for each
@@ -68,10 +83,14 @@ def filter_tools_for_ptc(
         allow_names: set[str] = set()
         for entry in config:
             if isinstance(entry, BaseTool):
+                if entry.name == _RESERVED_SUBAGENT_TASK_NAME:
+                    raise ValueError(_TASK_IN_PTC_MSG)
                 if entry.name != self_tool_name:
                     explicit_tools.append(entry)
                 continue
             if isinstance(entry, str):
+                if entry == _RESERVED_SUBAGENT_TASK_NAME:
+                    raise ValueError(_TASK_IN_PTC_MSG)
                 allow_names.add(entry)
                 continue
             msg = "ptc list entries must be str or BaseTool"
@@ -98,7 +117,7 @@ def filter_tools_for_ptc(
 
 
 def to_camel_case(name: str) -> str:
-    """Convert ``snake_case`` / ``kebab-case`` → ``camelCase``."""
+    """Convert `snake_case` / `kebab-case` → `camelCase`."""
     return _prompt.to_camel_case(name)