render-lab-tasks-agent 0.1.0__tar.gz

render_lab_tasks_agent-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+dist/
+*.egg-info/
+.env
+.env.*
+!.env.example

render_lab_tasks_agent-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Render Lab
+
+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.

render_lab_tasks_agent-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.5
+Name: render-lab-tasks-agent
+Version: 0.1.0
+Summary: agent tasks for Render Workflows
+Project-URL: Repository, https://github.com/render-lab/render-tasks-python
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: httpx<0.29,>=0.28
+Requires-Dist: render-lab-tasks-core<0.2,>=0.1.1
+Requires-Dist: render-lab-tasks-llm<0.2,>=0.1.1
+Requires-Dist: render==1.0.1
+Description-Content-Type: text/markdown
+
+# Agent tasks for Python
+
+Eight registered tasks cover planning, single decisions, loops, reflection,
+routing, history compression, named tools, and injected KV memory.
+Import the tasks and `app` from `render_lab_tasks_agent.tasks`.
+
+## Composition and environment
+
+LLM calls inherit the `render-lab-tasks-llm` provider/model/ledger environment
+contract. Credentials remain lazy. Raw decision implementations accept
+`CompletionDeps(complete=...)`; loops take `AgentDeps(step=..., tools=...)`.
+The default loop dispatches wrapped `agent.step` through `ctx.run` so every
+model decision is a durable child run. Register `ToolBinding` values with
+`register_agent_tool`; each binding's `run(ctx, args)` must dispatch wrapped
+Render tasks via `ctx.run` and return a string observation.
+
+`memory_impl` requires an injected `MemoryDeps(kv=...)`; there is no implicit
+in-memory fallback or default KV account. Re-register a wrapper under your own
+namespace to supply the store. No live agent/provider run verified this port.
+
+## Installation
+
+```sh
+pip install render-lab-tasks-agent==0.1.0
+```

render_lab_tasks_agent-0.1.0/README.md

@@ -0,0 +1,25 @@
+# Agent tasks for Python
+
+Eight registered tasks cover planning, single decisions, loops, reflection,
+routing, history compression, named tools, and injected KV memory.
+Import the tasks and `app` from `render_lab_tasks_agent.tasks`.
+
+## Composition and environment
+
+LLM calls inherit the `render-lab-tasks-llm` provider/model/ledger environment
+contract. Credentials remain lazy. Raw decision implementations accept
+`CompletionDeps(complete=...)`; loops take `AgentDeps(step=..., tools=...)`.
+The default loop dispatches wrapped `agent.step` through `ctx.run` so every
+model decision is a durable child run. Register `ToolBinding` values with
+`register_agent_tool`; each binding's `run(ctx, args)` must dispatch wrapped
+Render tasks via `ctx.run` and return a string observation.
+
+`memory_impl` requires an injected `MemoryDeps(kv=...)`; there is no implicit
+in-memory fallback or default KV account. Re-register a wrapper under your own
+namespace to supply the store. No live agent/provider run verified this port.
+
+## Installation
+
+```sh
+pip install render-lab-tasks-agent==0.1.0
+```

render_lab_tasks_agent-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "render-lab-tasks-agent"
+version = "0.1.0"
+description = "agent tasks for Render Workflows"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+dependencies = ["render-lab-tasks-llm>=0.1.1,<0.2","render==1.0.1", "httpx>=0.28,<0.29", "render-lab-tasks-core>=0.1.1,<0.2"]
+
+[project.urls]
+Repository = "https://github.com/render-lab/render-tasks-python"
+
+[tool.uv.sources]
+render-lab-tasks-llm = { workspace = true }
+render-lab-tasks-core = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/render_lab_tasks_agent"]

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/__init__.py

@@ -0,0 +1 @@
+"""Import .tasks explicitly to register durable tasks."""

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/_app.py

@@ -0,0 +1,3 @@
+from render import Workflows
+
+app = Workflows()

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/client.py

@@ -0,0 +1,64 @@
+"""Injected completions and a registry of durable tool bindings."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+
+from render import TaskContext
+from render_lab_tasks_llm.types import CompleteInput, CompleteResult
+
+from .types import AgentTool, Json, StepInput, StepResult
+
+
+@dataclass(frozen=True)
+class ToolBinding:
+    spec: AgentTool
+    run: Callable[[TaskContext, dict[str, Json]], Awaitable[str]]
+
+
+tool_registry: dict[str, ToolBinding] = {}
+
+
+def register_agent_tool(binding: ToolBinding) -> None:
+    tool_registry[binding.spec["name"]] = binding
+
+
+@dataclass(frozen=True)
+class CompletionDeps:
+    complete: Callable[[CompleteInput], Awaitable[CompleteResult]]
+
+
+def completion_deps(ctx: TaskContext, deps: CompletionDeps | None) -> CompletionDeps:
+    if deps is not None:
+        return deps
+    from render_lab_tasks_llm.complete import complete_impl
+
+    async def complete(input: CompleteInput) -> CompleteResult:
+        return await complete_impl(ctx, input)
+
+    return CompletionDeps(complete=complete)
+
+
+@dataclass(frozen=True)
+class AgentDeps:
+    step: Callable[[StepInput], Awaitable[StepResult]]
+    tools: dict[str, ToolBinding] = field(default_factory=lambda: tool_registry)
+
+
+def agent_deps(ctx: TaskContext, deps: AgentDeps | None) -> AgentDeps:
+    if deps is not None:
+        return deps
+    from .step import step
+
+    async def decide(input: StepInput) -> StepResult:
+        return await ctx.run(step, input)
+
+    return AgentDeps(step=decide)
+
+
+PlanDeps = CompletionDeps
+StepDeps = CompletionDeps
+ReflectDeps = CompletionDeps
+RouteDeps = CompletionDeps
+CompressHistoryDeps = CompletionDeps

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/compress_history.py

@@ -0,0 +1,34 @@
+from render import TaskContext
+from render_lab_tasks_llm.chat import resolve_model
+from render_lab_tasks_llm.types import CompleteInput
+
+from . import types as t
+from ._app import app
+from .client import CompletionDeps, completion_deps
+from .prompts import build_compress_prompt
+from .retry import AGENT_RETRY
+
+
+async def compress_history_impl(
+    ctx: TaskContext, input: t.CompressHistoryInput, *, deps: CompletionDeps | None = None
+) -> t.CompressHistoryResult:
+    if not input["history"]:
+        return {"summary": ""}
+    resolved = completion_deps(ctx, deps)
+    system, prompt = build_compress_prompt(input)
+    request: CompleteInput = {
+        "prompt": prompt,
+        "system": system,
+        "model": resolve_model(input.get("model")),
+    }
+    if "ledger" in input:
+        request["ledger"] = input["ledger"]
+    response = await resolved.complete(request)
+    return {"summary": response["text"].strip()}
+
+
+@app.task(name="agent.compressHistory", retry=AGENT_RETRY)
+async def compress_history(
+    ctx: TaskContext, input: t.CompressHistoryInput
+) -> t.CompressHistoryResult:
+    return await compress_history_impl(ctx, input)

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/loop.py

@@ -0,0 +1,64 @@
+from render import TaskContext
+from render_lab_tasks_core.http import nullish
+
+from ._app import app
+from .client import AgentDeps, agent_deps
+from .retry import AGENT_RETRY
+from .types import AgentStepRecord, LoopInput, LoopResult, StepInput
+
+
+async def loop_impl(
+    ctx: TaskContext, input: LoopInput, *, deps: AgentDeps | None = None
+) -> LoopResult:
+    resolved = agent_deps(ctx, deps)
+    tools = (
+        {name: resolved.tools[name] for name in input["toolNames"] if name in resolved.tools}
+        if input.get("toolNames") is not None
+        else resolved.tools
+    )
+    specs = [binding.spec for binding in tools.values()]
+    history: list[AgentStepRecord] = []
+    last = ""
+    i = 0
+    while i < nullish(input.get("maxSteps"), 10):
+        i += 1
+        request: StepInput = {"goal": input["goal"], "history": history.copy(), "tools": specs}
+        if "system" in input:
+            request["system"] = input["system"]
+        if "model" in input:
+            request["model"] = input["model"]
+        if "ledger" in input:
+            request["ledger"] = input["ledger"]
+        action = await resolved.step(request)
+        if action["type"] == "final":
+            return {
+                "answer": nullish(action.get("answer"), ""),
+                "steps": history,
+                "stepCount": len(history),
+                "stoppedReason": "final",
+            }
+        name = nullish(action.get("tool"), "")
+        record: AgentStepRecord = {"tool": name}
+        if "thought" in action:
+            record["thought"] = action["thought"]
+        if "args" in action:
+            record["args"] = action["args"]
+        if name not in tools:
+            record["observation"] = f'error: unknown tool "{name}"'
+        else:
+            last = await tools[name].run(ctx, nullish(action.get("args"), {}))
+            if not isinstance(last, str):
+                raise TypeError("Agent tools must return a string observation")
+            record["observation"] = last
+        history.append(record)
+    return {
+        "answer": last,
+        "steps": history,
+        "stepCount": len(history),
+        "stoppedReason": "maxSteps",
+    }
+
+
+@app.task(name="agent.loop", retry=AGENT_RETRY)
+async def loop(ctx: TaskContext, input: LoopInput) -> LoopResult:
+    return await loop_impl(ctx, input)

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/memory.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import Protocol
+
+from render import TaskContext
+
+from ._app import app
+from .retry import AGENT_RETRY
+from .types import MemoryInput, MemoryResult
+
+
+class MemoryKvPort(Protocol):
+    async def get(self, key: str) -> str | None: ...
+    async def set(self, key: str, value: str) -> None: ...
+
+
+@dataclass(frozen=True)
+class MemoryDeps:
+    kv: MemoryKvPort | None = None
+
+
+async def memory_impl(
+    ctx: TaskContext, input: MemoryInput, *, deps: MemoryDeps | None = None
+) -> MemoryResult:
+    if deps is None or deps.kv is None:
+        raise ValueError(
+            "agent.memory: no KV store configured — inject deps.kv (e.g. from "
+            "@render-lab/tasks-render-kv) with { get(key), set(key, value) }."
+        )
+    if input["op"] == "get":
+        return {"key": input["key"], "value": await deps.kv.get(input["key"])}
+    if input["op"] == "set":
+        if "value" not in input:
+            raise ValueError(f'agent.memory: "set" requires a value for key "{input["key"]}".')
+        await deps.kv.set(input["key"], input["value"])
+        return {"key": input["key"], "ok": True}
+    raise ValueError(f'agent.memory: unknown op "{input["op"]}" (expected "get" or "set").')
+
+
+@app.task(name="agent.memory", retry=AGENT_RETRY)
+async def memory(ctx: TaskContext, input: MemoryInput) -> MemoryResult:
+    return await memory_impl(ctx, input)

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/plan.py

@@ -0,0 +1,37 @@
+from render import TaskContext
+from render_lab_tasks_core.http import js_string
+from render_lab_tasks_llm.chat import resolve_model
+from render_lab_tasks_llm.json import extract_json
+from render_lab_tasks_llm.types import CompleteInput
+
+from . import types as t
+from ._app import app
+from .client import CompletionDeps, completion_deps
+from .prompts import build_plan_prompt
+from .retry import AGENT_RETRY
+
+
+async def plan_impl(
+    ctx: TaskContext, input: t.PlanInput, *, deps: CompletionDeps | None = None
+) -> t.PlanResult:
+    resolved = completion_deps(ctx, deps)
+    system, prompt = build_plan_prompt(input)
+    request: CompleteInput = {
+        "prompt": prompt,
+        "system": system,
+        "model": resolve_model(input.get("model")),
+    }
+    if "ledger" in input:
+        request["ledger"] = input["ledger"]
+    response = await resolved.complete(request)
+    parsed = extract_json(response["text"])
+    steps = parsed.get("steps") if isinstance(parsed, dict) else None
+    return {
+        "steps": [js_string(s) for s in steps] if isinstance(steps, list) else [],
+        "model": response["model"],
+    }
+
+
+@app.task(name="agent.plan", retry=AGENT_RETRY)
+async def plan(ctx: TaskContext, input: t.PlanInput) -> t.PlanResult:
+    return await plan_impl(ctx, input)

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/prompts.py

@@ -0,0 +1,140 @@
+"""Pure prompt builders for observable agent decisions."""
+
+import json
+
+from render_lab_tasks_core.http import js_string, nullish
+
+from . import types as t
+
+
+def compact(value: t.Json) -> str:
+    return json.dumps(value, ensure_ascii=False, allow_nan=False, separators=(",", ":"))
+
+
+def format_history(history: list[t.AgentStepRecord]) -> str:
+    if not history:
+        return "(none yet)"
+    lines = []
+    for i, item in enumerate(history):
+        parts = [f"{i + 1}."]
+        if item.get("thought"):
+            parts.append("thought: " + item["thought"])
+        if item.get("tool"):
+            parts.append(f"tool: {item['tool']}({compact(item.get('args', {}))})")
+        if "observation" in item:
+            parts.append("observation: " + item["observation"])
+        lines.append(" ".join(parts))
+    return "\n".join(lines)
+
+
+def build_step_prompt(input: t.StepInput) -> tuple[str, str]:
+    tools = (
+        "\n".join(
+            f"- {tool['name']}: {tool['description']} (args JSON Schema: "
+            f"{compact(tool['parameters'])})"
+            for tool in input["tools"]
+        )
+        or "(no tools available)"
+    )
+    lines = [input["system"].strip()] if "system" in input else []
+    system = "\n".join(
+        lines
+        + [
+            "You are a ReAct agent. You accomplish a goal by choosing one action at a time,",
+            "observing the result, and repeating until you can answer.",
+            "",
+            "Available tools:",
+            tools,
+            "",
+            "Respond with ONLY a single JSON object. No prose, no explanation, no markdown fences.",
+            'To call a tool: {"type":"tool","tool":"<name>","args":{ ... },"thought":"<why>"}',
+            'To finish: {"type":"final","answer":"<the answer>","thought":"<why>"}',
+            'The tool name MUST be one of the names listed above. Use type "final" '
+            "once you have enough information.",
+        ]
+    )
+    prompt = "\n".join(
+        [
+            f"Goal: {input['goal']}",
+            "",
+            "Steps so far:",
+            format_history(input["history"]),
+            "",
+            "What is your next action? Respond with ONLY the JSON object.",
+        ]
+    )
+    return system, prompt
+
+
+def build_plan_prompt(input: t.PlanInput) -> tuple[str, str]:
+    system = "\n".join(
+        [
+            "You are a planning assistant. Break a goal into a short, ordered list of",
+            "concrete steps an agent could execute.",
+            "",
+            'Respond with ONLY a JSON object of the form {"steps":["first step","second step"]}.',
+            "No prose, no markdown fences. Keep it to at most 6 steps.",
+        ]
+    )
+    return system, f"Goal: {input['goal']}" + (
+        f"\nContext:\n{input['context']}" if input.get("context") else ""
+    ) + "\nProduce the plan as JSON now."
+
+
+def build_reflect_prompt(input: t.ReflectInput) -> tuple[str, str]:
+    system = "\n".join(
+        [
+            "You are a critical reviewer of an agent's progress. Decide whether the goal",
+            "has been achieved and give a one-line critique of what to do next.",
+            "",
+            'Respond with ONLY a JSON object of the form {"done":true|false,"critique":"..."}.',
+            "No prose, no markdown fences.",
+        ]
+    )
+    return system, "\n".join(
+        [
+            f"Goal: {input['goal']}",
+            "",
+            "Steps so far:",
+            format_history(input["history"]),
+            "",
+            "Is the goal achieved? Respond with ONLY the JSON object.",
+        ]
+    )
+
+
+def build_compress_prompt(input: t.CompressHistoryInput) -> tuple[str, str]:
+    maximum = js_string(nullish(input.get("maxWords"), 150))
+    system = "\n".join(
+        [
+            "You compress an AI agent's scratchpad into a short summary so it fits in a",
+            "limited context window. Preserve the key facts, decisions, and open threads;",
+            "drop redundancy and verbatim tool output.",
+            "",
+            f"Respond with ONLY the summary as plain prose, at most {maximum} words.",
+            "No preamble, no markdown fences, no bullet headers.",
+        ]
+    )
+    return system, "\n".join(
+        ["History to summarize:", format_history(input["history"]), "", "Write the summary now."]
+    )
+
+
+def build_route_prompt(input: t.RouteInput) -> tuple[str, str]:
+    routes = "\n".join(f"- {r['name']}: {r['description']}" for r in input["routes"])
+    system = "\n".join(
+        [
+            "You are a router. Given a goal and a set of named routes, pick the single",
+            "best route to handle the goal.",
+            "",
+            "Available routes:",
+            routes,
+            "",
+            'Respond with ONLY a JSON object of the form {"route":"<name>","reasoning":"..."}.',
+            "The route MUST be exactly one of the names listed above. No prose, "
+            "no markdown fences.",
+        ]
+    )
+    return system, "\n".join(
+        [f"Goal: {input['goal']}", "", "Which route? Respond with ONLY the JSON object."]
+    )

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/reflect.py

@@ -0,0 +1,37 @@
+from render import TaskContext
+from render_lab_tasks_llm.chat import resolve_model
+from render_lab_tasks_llm.json import extract_json
+from render_lab_tasks_llm.types import CompleteInput
+
+from . import types as t
+from ._app import app
+from .client import CompletionDeps, completion_deps
+from .prompts import build_reflect_prompt
+from .retry import AGENT_RETRY
+
+
+async def reflect_impl(
+    ctx: TaskContext, input: t.ReflectInput, *, deps: CompletionDeps | None = None
+) -> t.ReflectResult:
+    resolved = completion_deps(ctx, deps)
+    system, prompt = build_reflect_prompt(input)
+    request: CompleteInput = {
+        "prompt": prompt,
+        "system": system,
+        "model": resolve_model(input.get("model")),
+    }
+    if "ledger" in input:
+        request["ledger"] = input["ledger"]
+    response = await resolved.complete(request)
+    parsed = extract_json(response["text"])
+    parsed = parsed if isinstance(parsed, dict) else {}
+    return {
+        "done": parsed.get("done") is True,
+        "critique": parsed["critique"] if isinstance(parsed.get("critique"), str) else "",
+        "model": response["model"],
+    }
+
+
+@app.task(name="agent.reflect", retry=AGENT_RETRY)
+async def reflect(ctx: TaskContext, input: t.ReflectInput) -> t.ReflectResult:
+    return await reflect_impl(ctx, input)

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/retry.py

@@ -0,0 +1,3 @@
+from render import Retry
+
+AGENT_RETRY = Retry(max_retries=2, wait_duration_ms=1000, backoff_scaling=2)

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/route.py

@@ -0,0 +1,48 @@
+from render import TaskContext
+from render_lab_tasks_llm.chat import resolve_model
+from render_lab_tasks_llm.json import extract_json
+from render_lab_tasks_llm.types import CompleteInput
+
+from . import types as t
+from ._app import app
+from .client import CompletionDeps, completion_deps
+from .prompts import build_route_prompt
+from .retry import AGENT_RETRY
+
+
+async def route_impl(
+    ctx: TaskContext, input: t.RouteInput, *, deps: CompletionDeps | None = None
+) -> t.RouteResult:
+    if not input["routes"]:
+        raise ValueError("agent.route: no routes provided to choose from.")
+    resolved = completion_deps(ctx, deps)
+    system, prompt = build_route_prompt(input)
+    request: CompleteInput = {
+        "prompt": prompt,
+        "system": system,
+        "model": resolve_model(input.get("model")),
+    }
+    if "ledger" in input:
+        request["ledger"] = input["ledger"]
+    response = await resolved.complete(request)
+    parsed = extract_json(response["text"])
+    parsed = parsed if isinstance(parsed, dict) else {}
+    chosen = parsed.get("route")
+    reasoning = parsed.get("reasoning")
+    reasoning = reasoning if isinstance(reasoning, str) else None
+    if isinstance(chosen, str) and any(r["name"] == chosen for r in input["routes"]):
+        result: t.RouteResult = {"route": chosen}
+        if reasoning is not None:
+            result["reasoning"] = reasoning
+        return result
+    return {
+        "route": input["routes"][0]["name"],
+        "reasoning": reasoning + " (fell back to first route)"
+        if reasoning
+        else "fell back to first route (model returned no valid route)",
+    }
+
+
+@app.task(name="agent.route", retry=AGENT_RETRY)
+async def route(ctx: TaskContext, input: t.RouteInput) -> t.RouteResult:
+    return await route_impl(ctx, input)

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/run_tool.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass, field
+
+from render import TaskContext
+from render_lab_tasks_core.http import nullish
+
+from ._app import app
+from .client import ToolBinding, tool_registry
+from .retry import AGENT_RETRY
+from .types import RunToolInput, RunToolResult
+
+
+@dataclass(frozen=True)
+class RunToolDeps:
+    tools: dict[str, ToolBinding] = field(default_factory=lambda: tool_registry)
+
+
+async def run_tool_impl(
+    ctx: TaskContext, input: RunToolInput, *, deps: RunToolDeps | None = None
+) -> RunToolResult:
+    tools = (deps or RunToolDeps()).tools
+    if input["tool"] not in tools:
+        raise ValueError(
+            f'agent.runTool: unknown tool "{input["tool"]}". Register it with '
+            f"registerAgentTool(...) before calling it."
+        )
+    output = await tools[input["tool"]].run(ctx, nullish(input.get("args"), {}))
+    if not isinstance(output, str):
+        raise TypeError("Agent tools must return a string observation")
+    return {"tool": input["tool"], "output": output}
+
+
+@app.task(name="agent.runTool", retry=AGENT_RETRY)
+async def run_tool(ctx: TaskContext, input: RunToolInput) -> RunToolResult:
+    return await run_tool_impl(ctx, input)

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/step.py

@@ -0,0 +1,46 @@
+import json
+from typing import cast
+
+from render import TaskContext
+from render_lab_tasks_llm.chat import resolve_model
+from render_lab_tasks_llm.json import extract_json
+from render_lab_tasks_llm.types import CompleteInput
+
+from . import types as t
+from ._app import app
+from .client import CompletionDeps, completion_deps
+from .prompts import build_step_prompt
+from .retry import AGENT_RETRY
+
+
+async def step_impl(
+    ctx: TaskContext, input: t.StepInput, *, deps: CompletionDeps | None = None
+) -> t.StepResult:
+    resolved = completion_deps(ctx, deps)
+    system, prompt = build_step_prompt(input)
+    request: CompleteInput = {
+        "prompt": prompt,
+        "system": system,
+        "model": resolve_model(input.get("model")),
+    }
+    if "ledger" in input:
+        request["ledger"] = input["ledger"]
+    response = await resolved.complete(request)
+    action = extract_json(response["text"])
+    if not isinstance(action, dict) or action.get("type") not in ("tool", "final"):
+        raise ValueError(
+            f"agent.step: could not parse a valid AgentAction from model output: "
+            f"{response['text'][:200]}"
+        )
+    if action["type"] == "tool" and not action.get("tool"):
+        raise ValueError(
+            f"agent.step: model returned a tool action without a tool name: "
+            f"{response['text'][:200]}"
+        )
+    json.dumps(action, allow_nan=False)
+    return cast(t.StepResult, {**action, "model": response["model"]})
+
+
+@app.task(name="agent.step", retry=AGENT_RETRY)
+async def step(ctx: TaskContext, input: t.StepInput) -> t.StepResult:
+    return await step_impl(ctx, input)

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/tasks.py

@@ -0,0 +1,29 @@
+from ._app import app
+from .compress_history import compress_history, compress_history_impl
+from .loop import loop, loop_impl
+from .memory import memory, memory_impl
+from .plan import plan, plan_impl
+from .reflect import reflect, reflect_impl
+from .route import route, route_impl
+from .run_tool import run_tool, run_tool_impl
+from .step import step, step_impl
+
+__all__ = [
+    "app",
+    "compress_history",
+    "compress_history_impl",
+    "loop",
+    "loop_impl",
+    "memory",
+    "memory_impl",
+    "plan",
+    "plan_impl",
+    "reflect",
+    "reflect_impl",
+    "route",
+    "route_impl",
+    "run_tool",
+    "run_tool_impl",
+    "step",
+    "step_impl",
+]

render_lab_tasks_agent-0.1.0/src/render_lab_tasks_agent/types.py

@@ -0,0 +1,140 @@
+"""JSON contracts ported from the pinned TypeScript pack."""
+
+from __future__ import annotations
+
+from typing import Literal, NotRequired, TypedDict
+
+
+class MemorySetResult(TypedDict):
+    key: str
+    ok: Literal[True]
+
+
+class MemoryGetResult(TypedDict):
+    key: str
+    value: str | None
+
+
+type Json = str | float | bool | None | list[Json] | dict[str, Json]
+
+
+class AgentTool(TypedDict):
+    name: str
+    description: str
+    parameters: dict[str, Json]
+
+
+class AgentStepRecord(TypedDict):
+    thought: NotRequired[str]
+    tool: NotRequired[str]
+    args: NotRequired[dict[str, Json]]
+    observation: NotRequired[str]
+
+
+class AgentAction(TypedDict):
+    type: Literal["tool"] | Literal["final"]
+    thought: NotRequired[str]
+    tool: NotRequired[str]
+    args: NotRequired[dict[str, Json]]
+    answer: NotRequired[str]
+
+
+class PlanInput(TypedDict):
+    goal: str
+    context: NotRequired[str]
+    model: NotRequired[str]
+    ledger: NotRequired[str]
+
+
+class PlanResult(TypedDict):
+    steps: list[str]
+    model: str
+
+
+class StepInput(TypedDict):
+    goal: str
+    history: list[AgentStepRecord]
+    tools: list[AgentTool]
+    system: NotRequired[str]
+    model: NotRequired[str]
+    ledger: NotRequired[str]
+
+
+class StepResult(AgentAction):
+    model: str
+
+
+class ReflectInput(TypedDict):
+    goal: str
+    history: list[AgentStepRecord]
+    model: NotRequired[str]
+    ledger: NotRequired[str]
+
+
+class ReflectResult(TypedDict):
+    done: bool
+    critique: str
+    model: str
+
+
+class LoopInput(TypedDict):
+    goal: str
+    toolNames: NotRequired[list[str]]
+    maxSteps: NotRequired[float]
+    system: NotRequired[str]
+    model: NotRequired[str]
+    ledger: NotRequired[str]
+
+
+class LoopResult(TypedDict):
+    answer: str
+    steps: list[AgentStepRecord]
+    stepCount: float
+    stoppedReason: Literal["final"] | Literal["maxSteps"]
+
+
+class RunToolInput(TypedDict):
+    tool: str
+    args: NotRequired[dict[str, Json]]
+
+
+class RunToolResult(TypedDict):
+    tool: str
+    output: str
+
+
+class CompressHistoryInput(TypedDict):
+    history: list[AgentStepRecord]
+    maxWords: NotRequired[float]
+    model: NotRequired[str]
+    ledger: NotRequired[str]
+
+
+class CompressHistoryResult(TypedDict):
+    summary: str
+
+
+class AgentRoute(TypedDict):
+    name: str
+    description: str
+
+
+class RouteInput(TypedDict):
+    goal: str
+    routes: list[AgentRoute]
+    model: NotRequired[str]
+    ledger: NotRequired[str]
+
+
+class RouteResult(TypedDict):
+    route: str
+    reasoning: NotRequired[str]
+
+
+class MemoryInput(TypedDict):
+    op: Literal["get"] | Literal["set"]
+    key: str
+    value: NotRequired[str]
+
+
+type MemoryResult = MemoryGetResult | MemorySetResult