steerable-agent-runtime 0.2.5__tar.gz → 0.4.0__tar.gz

{steerable_agent_runtime-0.2.5 → steerable_agent_runtime-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.2.5
+Version: 0.4.0
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -13,14 +13,14 @@ Provides-Extra: fastapi
 Requires-Dist: fastapi>=0.110; extra == "fastapi"
 Requires-Dist: starlette>=0.37; extra == "fastapi"
 Provides-Extra: openai
-Requires-Dist: httpx>=0.27; extra == "openai"
+Requires-Dist: httpx[socks]>=0.27; extra == "openai"
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.40; extra == "anthropic"
 Provides-Extra: all
 Requires-Dist: sqlalchemy>=2.0; extra == "all"
 Requires-Dist: fastapi>=0.110; extra == "all"
 Requires-Dist: starlette>=0.37; extra == "all"
-Requires-Dist: httpx>=0.27; extra == "all"
+Requires-Dist: httpx[socks]>=0.27; extra == "all"
 Requires-Dist: anthropic>=0.40; extra == "all"
 
 # steerable-agent-runtime

{steerable_agent_runtime-0.2.5 → steerable_agent_runtime-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.2.5"
+version = "0.4.0"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -18,13 +18,17 @@ dependencies = [
 [project.optional-dependencies]
 sqlalchemy = ["sqlalchemy>=2.0"]
 fastapi = ["fastapi>=0.110", "starlette>=0.37"]
-openai = ["httpx>=0.27"]
+# The `socks` extra is not optional in practice: httpx builds a transport for
+# every proxy the environment declares while the client is constructed, so a
+# host exporting `all_proxy=socks5://…` — the common shell proxy snippet — makes
+# construction raise without it, failing provider calls that never reach a URL.
+openai = ["httpx[socks]>=0.27"]
 anthropic = ["anthropic>=0.40"]
 all = [
   "sqlalchemy>=2.0",
   "fastapi>=0.110",
   "starlette>=0.37",
-  "httpx>=0.27",
+  "httpx[socks]>=0.27",
   "anthropic>=0.40",
 ]
 
@@ -38,6 +42,12 @@ package-dir = {"" = "src"}
 [tool.setuptools.packages.find]
 where = ["src"]
 
+# default.harness.yaml/.json ship inside the wheel: the sidecar resolves
+# the spec relative to the installed package (Harbor trial containers
+# pip-install the wheels, so a repo-relative path would not exist there).
+[tool.setuptools.package-data]
+steerable_agent_runtime = ["*.yaml", "*.json"]
+
 [tool.uv.sources]
 steerable-agent-protocol = { workspace = true }
 steerable-agent-harness = { workspace = true }

steerable_agent_runtime-0.4.0/src/steerable_agent_runtime/__init__.py

@@ -0,0 +1,410 @@
+"""Steerable agent runtime — Tier 3 adapter package."""
+
+from .antihallucination import (
+    AntiHallucinationConfig,
+    AntiHallucinationHooks,
+    detect_claimed_execution,
+    detect_deferred_execution,
+    detect_deferred_execution_eager,
+    detect_execution_intent_in_user_message,
+    parse_grounding_verdict,
+    parse_turn_route,
+    should_run_grounding_judge,
+)
+from .approval import (
+    ApprovalDecision,
+    ApprovalExecutor,
+    ApprovalRequest,
+    ApprovalStore,
+    Approver,
+    AutoApprover,
+    InMemoryApprovalStore,
+    JsonApprovalStore,
+    SessionApprovalCache,
+)
+from .approval_policy import (
+    ApprovalPolicy,
+    ApprovalRule,
+    JsonApprovalPolicyStore,
+    PolicyApprover,
+    rule_from_amendment,
+)
+from .branch import (
+    BranchPoint,
+    ForkResult,
+    branch_label,
+    fork_record,
+    lineage,
+    resolve_fork_seq,
+)
+from .cache_control import (
+    CacheControlProvider,
+    CacheRetention,
+    place_cache_breakpoints,
+    system_blocks_with_cache,
+)
+from .calibration import CalibratingProvider, ModelCalibration, UsageCalibration
+from .compaction import CompactionHooks
+from .errors import (
+    ApprovalAborted,
+    BudgetExhaustedError,
+    PolicyDeniedError,
+    StorageError,
+    ToolDispatchError,
+    TransportError,
+)
+from .errors import (
+    RuntimeError as SteerableRuntimeError,
+)
+from .history import (
+    RECORD_FORMAT_VERSION,
+    CompactionBoundary,
+    ContextFragment,
+    ContextManager,
+    HistoryItem,
+    HistorySeed,
+    HistoryStore,
+    RecordEntry,
+    RecordFormatError,
+    SystemPromptFragment,
+    entry_from_dict,
+    render_fragment_capped,
+    entry_to_dict,
+    message_from_dict,
+    message_to_dict,
+    upgrade_entry_dict,
+)
+from .hooks import (
+    ChainHooks,
+    CompletionAction,
+    CompletionDraft,
+    LoopHooks,
+    NoopHooks,
+    PreStepAction,
+    RetryAction,
+    RewriteRequest,
+    TranscriptAppend,
+)
+from .llm import (
+    ContentPart,
+    ImagePart,
+    LLMMessage,
+    LLMProvider,
+    LLMStreamChunk,
+    LLMUsage,
+    TextPart,
+    text_parts,
+)
+from .loop import (
+    CompletionDecision,
+    CoreLoop,
+    LoopConfig,
+    LoopContext,
+    LoopEvent,
+    RouterToolExecutor,
+    ToolExecutor,
+)
+from .mcp import (
+    DEFAULT_MAX_SERVER_TOOLS,
+    McpCallResult,
+    McpCatalogError,
+    McpError,
+    McpStdioClient,
+    McpToolInfo,
+    mcp_invoker,
+    parse_mcp_name,
+    qualify_mcp_name,
+    register_mcp_catalog,
+)
+from .model_info import (
+    MODEL_INFOS,
+    REASONING_EFFORT_ORDER,
+    ModelInfo,
+    clamp_reasoning_effort,
+    register_model_info,
+    resolve_model_info,
+)
+from .orchestration import (
+    AgentPool,
+    ChildOutcome,
+    OrchestrationBudgetExceeded,
+    OrchestrationConfig,
+    OrchestrationExecutor,
+    orchestration_tool_descriptors,
+)
+from .otel import PrivacyMode, export_otlp_http, export_trace, to_otlp_json
+from .pricing import (
+    MODEL_PRICES,
+    ModelPrice,
+    estimate_cost_usd,
+    price_for_model,
+    register_model_price,
+)
+from .pseudo import extract_inline_tool_calls
+from .recording import (
+    DEFAULT_MAX_ITEM_TOKENS,
+    InMemoryRequestSink,
+    JsonlRequestSink,
+    RecordedRequest,
+    RecordingProvider,
+    RequestSink,
+    assert_bounded_items,
+    assert_requests_match_record,
+    assert_stable_prefix,
+    load_recorded_requests,
+)
+from .replay import (
+    ExecutionBudget,
+    HarnessExecutionState,
+    HarnessTrajectoryEvent,
+    build_step_decision_event,
+    reduce_execution_state,
+)
+from .resume import (
+    close_dangling_tool_calls,
+    load_history_transcript,
+    load_transcript,
+    project_transcript,
+)
+from .retry import RetryHooks
+from .sandboxed import (
+    DEFAULT_SHELL_TOOLS,
+    SandboxBackend,
+    SandboxedToolExecutor,
+    SandboxEnforcement,
+)
+from .skills import (
+    EAGER_PRIORITY_THRESHOLD,
+    FilesystemSkillProvider,
+    SkillConfig,
+    SkillDefinition,
+    SkillExecutor,
+    SkillHooks,
+    SkillProvider,
+    SkillSummary,
+    matches_conditions,
+    render_skill_catalog,
+    select_catalog,
+    select_skills,
+    skill_to_dict,
+    skill_tool_descriptor,
+)
+from .spill import FilesystemSpillStore, InMemorySpillStore, SpillHooks, SpillStore
+from .storage import StorageAdapter
+from .subagent import (
+    FilteredToolsExecutor,
+    SubagentConfig,
+    SubagentExecutor,
+    subagent_tool_descriptor,
+)
+from .tokens import (
+    MODEL_TOKEN_FACTORS,
+    estimate_text_tokens,
+    estimate_tokens,
+    factor_for_model,
+    register_model_factor,
+)
+from .tool_search import TOOL_SEARCH_NAME, register_tool_search, tool_search_descriptor
+from .tools import RegisteredTool, ToolExposure, ToolRouter, tool
+from .tracing import TraceRecorder
+from .transport import TransportAdapter
+from .world_state import (
+    StaticWorldStateSection,
+    WorldStateFragment,
+    WorldStateHooks,
+    WorldStatePatchFragment,
+    WorldStateSection,
+    apply_merge_patch,
+    last_world_state_snapshot,
+    merge_patch,
+)
+
+__all__ = [
+    "DEFAULT_MAX_ITEM_TOKENS",
+    "DEFAULT_MAX_SERVER_TOOLS",
+    "DEFAULT_SHELL_TOOLS",
+    "EAGER_PRIORITY_THRESHOLD",
+    "MODEL_INFOS",
+    "MODEL_PRICES",
+    "MODEL_TOKEN_FACTORS",
+    "REASONING_EFFORT_ORDER",
+    "RECORD_FORMAT_VERSION",
+    "TOOL_SEARCH_NAME",
+    "AgentPool",
+    "AntiHallucinationConfig",
+    "AntiHallucinationHooks",
+    "ApprovalAborted",
+    "ApprovalDecision",
+    "ApprovalExecutor",
+    "ApprovalPolicy",
+    "ApprovalRequest",
+    "ApprovalRule",
+    "ApprovalStore",
+    "Approver",
+    "AutoApprover",
+    "BranchPoint",
+    "BudgetExhaustedError",
+    "CacheControlProvider",
+    "CacheRetention",
+    "CalibratingProvider",
+    "ChainHooks",
+    "ChildOutcome",
+    "CompactionBoundary",
+    "CompactionHooks",
+    "CompletionAction",
+    "CompletionDecision",
+    "CompletionDraft",
+    "ContentPart",
+    "ContextFragment",
+    "ContextManager",
+    "CoreLoop",
+    "ExecutionBudget",
+    "FilesystemSkillProvider",
+    "FilesystemSpillStore",
+    "FilteredToolsExecutor",
+    "ForkResult",
+    "HarnessExecutionState",
+    "HarnessTrajectoryEvent",
+    "HistoryItem",
+    "HistorySeed",
+    "HistoryStore",
+    "ImagePart",
+    "InMemoryApprovalStore",
+    "InMemoryRequestSink",
+    "InMemorySpillStore",
+    "JsonApprovalPolicyStore",
+    "JsonApprovalStore",
+    "JsonlRequestSink",
+    "LLMMessage",
+    "LLMProvider",
+    "LLMStreamChunk",
+    "LLMUsage",
+    "LoopConfig",
+    "LoopContext",
+    "LoopEvent",
+    "LoopHooks",
+    "McpCallResult",
+    "McpCatalogError",
+    "McpError",
+    "McpStdioClient",
+    "McpToolInfo",
+    "ModelCalibration",
+    "ModelInfo",
+    "ModelPrice",
+    "NoopHooks",
+    "OrchestrationBudgetExceeded",
+    "OrchestrationConfig",
+    "OrchestrationExecutor",
+    "PolicyApprover",
+    "PolicyDeniedError",
+    "PreStepAction",
+    "PrivacyMode",
+    "RecordEntry",
+    "RecordFormatError",
+    "RecordedRequest",
+    "RecordingProvider",
+    "RegisteredTool",
+    "RequestSink",
+    "RetryAction",
+    "RetryHooks",
+    "RewriteRequest",
+    "RouterToolExecutor",
+    "SandboxBackend",
+    "SandboxEnforcement",
+    "SandboxedToolExecutor",
+    "SessionApprovalCache",
+    "SkillConfig",
+    "SkillDefinition",
+    "SystemPromptFragment",
+    "SkillExecutor",
+    "SkillHooks",
+    "SkillProvider",
+    "SkillSummary",
+    "SpillHooks",
+    "SpillStore",
+    "StaticWorldStateSection",
+    "SteerableRuntimeError",
+    "StorageAdapter",
+    "StorageError",
+    "SubagentConfig",
+    "SubagentExecutor",
+    "TextPart",
+    "ToolDispatchError",
+    "ToolExecutor",
+    "ToolExposure",
+    "ToolRouter",
+    "TraceRecorder",
+    "TranscriptAppend",
+    "TransportAdapter",
+    "TransportError",
+    "UsageCalibration",
+    "WorldStateFragment",
+    "WorldStateHooks",
+    "WorldStatePatchFragment",
+    "WorldStateSection",
+    "apply_merge_patch",
+    "assert_bounded_items",
+    "assert_requests_match_record",
+    "assert_stable_prefix",
+    "branch_label",
+    "build_step_decision_event",
+    "clamp_reasoning_effort",
+    "close_dangling_tool_calls",
+    "detect_claimed_execution",
+    "detect_deferred_execution",
+    "detect_deferred_execution_eager",
+    "detect_execution_intent_in_user_message",
+    "entry_from_dict",
+    "entry_to_dict",
+    "estimate_cost_usd",
+    "estimate_text_tokens",
+    "estimate_tokens",
+    "export_otlp_http",
+    "export_trace",
+    "extract_inline_tool_calls",
+    "factor_for_model",
+    "fork_record",
+    "last_world_state_snapshot",
+    "lineage",
+    "load_history_transcript",
+    "load_recorded_requests",
+    "load_transcript",
+    "matches_conditions",
+    "mcp_invoker",
+    "merge_patch",
+    "message_from_dict",
+    "message_to_dict",
+    "orchestration_tool_descriptors",
+    "parse_grounding_verdict",
+    "parse_mcp_name",
+    "parse_turn_route",
+    "place_cache_breakpoints",
+    "price_for_model",
+    "project_transcript",
+    "qualify_mcp_name",
+    "reduce_execution_state",
+    "register_mcp_catalog",
+    "register_model_factor",
+    "register_model_info",
+    "register_model_price",
+    "register_tool_search",
+    "render_fragment_capped",
+    "render_skill_catalog",
+    "resolve_fork_seq",
+    "resolve_model_info",
+    "rule_from_amendment",
+    "select_catalog",
+    "select_skills",
+    "should_run_grounding_judge",
+    "skill_to_dict",
+    "skill_tool_descriptor",
+    "subagent_tool_descriptor",
+    "system_blocks_with_cache",
+    "text_parts",
+    "to_otlp_json",
+    "tool",
+    "tool_search_descriptor",
+    "upgrade_entry_dict",
+]
+
+__version__ = "0.1.0"

{steerable_agent_runtime-0.2.5 → steerable_agent_runtime-0.4.0}/src/steerable_agent_runtime/antihallucination.py

@@ -471,28 +471,27 @@ class AntiHallucinationHooks(NoopHooks):
             or not self._config.force_tool_choice
             or not self._config.tools_available
         ):
-            return PreStepAction(kind="proceed", transcript=transcript)
+            return PreStepAction(kind="proceed")
         self._route = await self._classify_route()
         if self._route == "require_tool":
             return PreStepAction(
                 kind="proceed",
-                transcript=transcript,
                 tool_choice=self._config.force_tool_choice,
             )
-        return PreStepAction(kind="proceed", transcript=transcript)
+        return PreStepAction(kind="proceed")
 
     async def _classify_route(self) -> DataNeedRoute:
         from .llm import LLMMessage
 
         try:
             messages = [
-                LLMMessage(role=m["role"], content=m["content"])
+                LLMMessage.text_of(m["role"], m["content"])
                 for m in build_turn_route_messages(
                     self._config.user_question, self._config.last_assistant_tail
                 )
             ]
             reply, _usage = await self._provider.complete(messages, temperature=0)
-            parsed = parse_turn_route(reply.content or "")
+            parsed = parse_turn_route(reply.content_text)
             if parsed:
                 return parsed["route"]  # type: ignore[return-value]
         except Exception:
@@ -594,11 +593,11 @@ class AntiHallucinationHooks(NoopHooks):
 
         try:
             messages = [
-                LLMMessage(role=m["role"], content=m["content"])
+                LLMMessage.text_of(m["role"], m["content"])
                 for m in build_grounding_messages(user_question, assistant_reply)
             ]
             reply, _usage = await self._provider.complete(messages, temperature=0)
-            return parse_grounding_verdict(reply.content or "")
+            return parse_grounding_verdict(reply.content_text)
         except Exception:
             return None