feat: sync latest ARR implementation

arr_web/processing_runtime.py

@@ -1,4 +1,4 @@
-"""Production composition for XML upload and Open Agent dispatch."""
+"""Production composition for ARR-owned programmatic XML processing."""
 
 from __future__ import annotations
 
@@ -7,123 +7,69 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable, Optional
 
-from agent_integration import (
-    AgentConfig,
-    OpenAgentAPIClient,
-    OpenAgentService,
-    SQLiteSessionStore,
-)
-from arr_ingestion.postgres import DatabaseConfig
-from arr_ingestion.direct_postgres import PostgresDirectIngestionRepository
-from arr_processing.config import ResultVerificationConfig
-from arr_processing.open_agent import OpenAgentProcessingTransport
-from arr_processing.postgres import PostgresProcessingState, ProcessingDatabaseConfig
-from arr_processing.runner import ProcessingRunner
-from arr_processing.source_message import OssProcessingMessageBuilder
+from arr_ingestion.postgres import DatabaseConfig, PostgresIngestionRepository
+from arr_ingestion.service import IngestionService
+from arr_ingestion.validation import DeliveryValidator
+from arr_processing.local import LocalDailyProcessor
+from arr_processing.policy import load_processor_policy
 from arr_storage.aliyun_oss_v2 import AliyunOssConfig, AliyunOssV2Client
 from arr_storage.contracts import ObjectKeyPolicy
 from arr_storage.remote import CloudObjectBackend
 from arr_storage.store import ManagedObjectStore
-from arr_web.agent_writeback_runtime import load_processor_policy
-from arr_web.services import ObjectStoreUploadCoordinator
+from arr_web.programmatic import ProgrammaticUploadCoordinator
 
 
 @dataclass
 class ProcessingInputRuntime:
-    coordinator: ObjectStoreUploadCoordinator
-    api_client: OpenAgentAPIClient
-    session_store: SQLiteSessionStore
+    coordinator: ProgrammaticUploadCoordinator
     oss_client: AliyunOssV2Client
+    object_store: ManagedObjectStore
 
     def close(self) -> None:
-        errors = []
-        for close in (
-            self.api_client.close,
-            self.session_store.close,
-            self.oss_client.close,
-        ):
-            try:
-                close()
-            except Exception as error:  # pragma: no cover - best-effort shutdown
-                errors.append(error)
-        if errors:
-            raise errors[0]
+        self.oss_client.close()
 
 
-def compose_oss_processing_input(
+def compose_programmatic_processing(
     *,
     project_root: Path,
     connect: Optional[Callable[[str], Any]] = None,
 ) -> ProcessingInputRuntime:
-    oss_client: Optional[AliyunOssV2Client] = None
-    session_store: Optional[SQLiteSessionStore] = None
-    api_client: Optional[OpenAgentAPIClient] = None
+    oss_client = AliyunOssV2Client(AliyunOssConfig.from_environment())
     try:
-        agent_config = AgentConfig.from_env()
-        verification = ResultVerificationConfig.from_environment()
-        processor_policy = load_processor_policy(project_root)
-        oss_config = AliyunOssConfig.from_environment()
-        oss_client = AliyunOssV2Client(oss_config)
         oss_client.assert_immutable_writes_supported()
         object_store = ManagedObjectStore(
             CloudObjectBackend(oss_client),
             ObjectKeyPolicy(os.environ.get("ARR_OBJECT_PREFIX", "arr")),
         )
-        processing_config = (
-            ProcessingDatabaseConfig("controlled")
-            if connect is not None
-            else ProcessingDatabaseConfig.from_environment()
-        )
-        ingestion_config = (
+        database_config = (
             DatabaseConfig("controlled")
             if connect is not None
             else DatabaseConfig.from_environment()
         )
-        session_store = SQLiteSessionStore(agent_config.session_db)
-        if agent_config.api_key is None:
-            raise ValueError("Agent API key is unavailable")
-        api_client = OpenAgentAPIClient(
-            base_url=agent_config.base_url,
-            api_key=agent_config.api_key,
-            auth_mode=agent_config.auth_mode,
-            timeout=agent_config.timeout_seconds,
-            connect_timeout=agent_config.connect_timeout_seconds,
+        repository = PostgresIngestionRepository(
+            database_config,
+            connect=connect,
         )
-        service = OpenAgentService(api_client, session_store)
-        processing_state = PostgresProcessingState(processing_config, connect=connect)
-        runner = ProcessingRunner(
-            OpenAgentProcessingTransport(
-                service,
-                message_builder=OssProcessingMessageBuilder(
-                    oss_config,
-                    processing_state,
-                ).message,
-            ),
-            processing_state,
-            verification.verifier(),
-        )
-        coordinator = ObjectStoreUploadCoordinator(
+        policy = load_processor_policy(project_root)
+        coordinator = ProgrammaticUploadCoordinator(
             object_store=object_store,
-            ingestion_repository=PostgresDirectIngestionRepository(
-                ingestion_config,
-                connect=connect,
+            ingestion_repository=repository,
+            ingestion_service=IngestionService(
+                DeliveryValidator(object_store, policy),
+                repository,
             ),
-            processing_starter=runner,
-            processor_version=processor_policy.processor_version,
-            rule_set_sha256=processor_policy.rule_set_sha256,
-        )
-        return ProcessingInputRuntime(
-            coordinator,
-            api_client,
-            session_store,
-            oss_client,
+            processor=LocalDailyProcessor(policy),
+            processor_version=policy.processor_version,
+            rule_set_sha256=policy.rule_set_sha256,
         )
+        return ProcessingInputRuntime(coordinator, oss_client, object_store)
     except Exception:
-        for resource in (api_client, session_store, oss_client):
-            if resource is None:
-                continue
-            try:
-                resource.close()
-            except Exception:
-                pass
+        try:
+            oss_client.close()
+        except Exception:
+            pass
         raise
+
+
+# Compatibility name for older local launch wrappers.
+compose_oss_processing_input = compose_programmatic_processing