@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/openai_forwarding.py

@@ -0,0 +1,194 @@
+"""OpenAI-compatible chat forwarding application service."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIForwardPolicy:
+    compatibility_test_header: str
+    provider_requires_streaming: Callable[..., bool]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIForwardRequest:
+    update_tool_schema_registry: Callable[..., Any]
+    normalize_thinking: Callable[..., Any]
+    resolve_model: Callable[..., str]
+    provider_upstream_model: Callable[..., str]
+    body_with_advisor_tool: Callable[..., Any]
+    advisor_provider_supported: Callable[..., bool]
+    join_url: Callable[..., str]
+    upstream_request_base: Callable[..., str]
+    build_chat_request: Callable[..., Any]
+    provider_headers: Callable[..., dict[str, str]]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIForwardRateLimit:
+    apply: Callable[..., tuple[float, int, int]]
+    notice: Callable[..., str]
+    estimate_tokens: Callable[..., int]
+    request_timeout_seconds: Callable[..., float]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIForwardAdvisor:
+    model_enabled: Callable[..., bool]
+    gate_possible_for_body: Callable[..., bool]
+    gate_reason_for_body: Callable[..., str]
+    refine_message: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIForwardStreaming:
+    write_open_start: Callable[..., Any]
+    write_blocks: Callable[..., int]
+    open_with_retry: Callable[..., Any]
+    post_json_with_retry: Callable[..., Any]
+    stream_to_anthropic_sse: Callable[..., bool]
+    write_open_stop: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIForwardResponse:
+    mark_delivery_success: Callable[..., Any]
+    mark_delivery_failed: Callable[..., Any]
+    write_activity: Callable[..., Any]
+    chat_to_anthropic: Callable[..., Any]
+    remember_tool_uses: Callable[..., Any]
+    prepend_text: Callable[..., Any]
+    write_message: Callable[..., Any]
+    write_json: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIForwardServices:
+    policy: OpenAIForwardPolicy
+    request: OpenAIForwardRequest
+    rate_limit: OpenAIForwardRateLimit
+    advisor: OpenAIForwardAdvisor
+    streaming: OpenAIForwardStreaming
+    response: OpenAIForwardResponse
+    log: Callable[[str, str], Any]
+
+
+def forward_openai_compatible_chat(
+    handler: Any,
+    provider: str,
+    pcfg: dict[str, Any],
+    body: dict[str, Any],
+    *,
+    services: OpenAIForwardServices,
+) -> None:
+    """Forward one Anthropic-facing request through an OpenAI-compatible provider."""
+
+    policy = services.policy
+    request = services.request
+    rate_limit = services.rate_limit
+    advisor = services.advisor
+    streaming = services.streaming
+    response = services.response
+
+    request.update_tool_schema_registry(body.get("tools"))
+    body = request.normalize_thinking(provider, pcfg, body)
+    model = request.resolve_model(provider, pcfg, body.get("model"))
+    model = request.provider_upstream_model(provider, pcfg, model)
+    original_body = body
+    upstream_body = request.body_with_advisor_tool(body, pcfg) if request.advisor_provider_supported(provider) else body
+    url = request.join_url(request.upstream_request_base(provider, pcfg), "/v1/chat/completions")
+    waited, rpm_used, rpm_limit = rate_limit.apply(provider, pcfg, model)
+    compatibility_test = str(handler.headers.get(policy.compatibility_test_header) or "").strip().lower() in ("1", "true", "yes", "on")
+    stream_enabled = bool(pcfg.get("stream_enabled", True))
+    stream = policy.provider_requires_streaming(provider, pcfg) or (bool(body.get("stream", stream_enabled)) and stream_enabled)
+    if stream and advisor.model_enabled(pcfg) and request.advisor_provider_supported(provider):
+        stream = False
+        services.log("INFO", f"advisor tool enabled for {provider}; collecting this turn so advisor tool calls can be resolved internally")
+    if stream and advisor.gate_possible_for_body(provider, pcfg, body):
+        gate_reason = advisor.gate_reason_for_body(provider, pcfg, body)
+        stream = False
+        services.log("INFO", f"advisor gate enabled for {provider} reason={gate_reason}; collecting this turn before returning it to Claude Code")
+    notice = rate_limit.notice(waited, rpm_used, rpm_limit, bool(pcfg.get("rate_limit_status", False)))
+    if stream:
+        req_body = request.build_chat_request(provider, model, upstream_body, pcfg, stream=True)
+        req_tokens = rate_limit.estimate_tokens(req_body)
+        req_bytes = len(json.dumps(req_body, ensure_ascii=False).encode("utf-8"))
+        streaming.write_open_start(handler, model, input_tokens=req_tokens)
+        index = 0
+        if notice:
+            index = streaming.write_blocks(handler, [{"type": "text", "text": notice}], index)
+        try:
+            def emit_retry_notice(text: str) -> None:
+                nonlocal index
+                index = streaming.write_blocks(handler, [{"type": "text", "text": text + "\n"}], index)
+
+            upstream_response = streaming.open_with_retry(
+                url,
+                req_body,
+                request.provider_headers(
+                    provider, pcfg, handler.headers, "openai_chat"
+                ),
+                rate_limit.request_timeout_seconds(pcfg),
+                provider,
+                pcfg,
+                model,
+                emit_retry_notice,
+                retry_rate_limits=not compatibility_test,
+            )
+            stream_ok = streaming.stream_to_anthropic_sse(
+                handler,
+                upstream_response,
+                model,
+                provider,
+                source_body=original_body,
+                start_index=index,
+                word_chunking=bool(pcfg.get("stream_word_chunking", False)),
+                input_tokens=req_tokens,
+                input_bytes=req_bytes,
+            )
+            if stream_ok:
+                response.mark_delivery_success(handler, "openai_stream_message_stop")
+                response.write_activity("success", provider, model, tokens=req_tokens, bytes=req_bytes, stream=True)
+            else:
+                response.mark_delivery_failed(handler, "openai_stream_error")
+        except RuntimeError as exc:
+            response.mark_delivery_failed(handler, f"openai_stream_runtime_error:{type(exc).__name__}")
+            streaming.write_blocks(handler, [{"type": "text", "text": f"Upstream error: {exc}"}], index)
+            streaming.write_open_stop(handler)
+            return
+        except Exception as exc:
+            message = f"{type(exc).__name__}: {exc}"
+            response.mark_delivery_failed(handler, f"openai_stream_error:{type(exc).__name__}")
+            response.write_activity("error", provider, model, error=type(exc).__name__, stream=True)
+            streaming.write_blocks(handler, [{"type": "text", "text": f"Upstream error: {message}"}], index)
+            streaming.write_open_stop(handler)
+            return
+        return
+
+    req_body = request.build_chat_request(provider, model, upstream_body, pcfg, stream=False)
+    try:
+        data = streaming.post_json_with_retry(
+            url,
+            req_body,
+            request.provider_headers(
+                provider, pcfg, handler.headers, "openai_chat"
+            ),
+            rate_limit.request_timeout_seconds(pcfg),
+            provider,
+            pcfg,
+            model,
+            None,
+            retry_rate_limits=not compatibility_test,
+        )
+    except RuntimeError as exc:
+        response.write_json(handler, {"type": "error", "error": {"type": "upstream_error", "message": str(exc)}}, 500)
+        return
+    message = response.chat_to_anthropic(data, model, source_body=original_body)
+    message = advisor.refine_message(provider, pcfg, original_body, message, model)
+    response.remember_tool_uses(original_body, message)
+    message = response.prepend_text(message, notice)
+    response.write_message(handler, message, stream)
+    response.mark_delivery_success(handler, "openai_json")

package/ciel_runtime_support/openai_responses_router.py

@@ -0,0 +1,291 @@
+"""OpenAI Responses HTTP routing application service."""
+
+from __future__ import annotations
+
+import urllib.error
+import urllib.parse
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIResponsesCore:
+    event_bus: Any
+    request_id: Callable[[], str]
+    input_as_list: Callable[[Any], list[Any]]
+    is_client_disconnect: Callable[[BaseException], bool]
+    log: Callable[[str, str], Any]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIResponsesConversion:
+    to_anthropic: Callable[..., dict[str, Any]]
+    current_alias: Callable[[dict[str, Any]], str]
+    update_tool_schema: Callable[[Any], Any]
+    normalize_thinking: Callable[..., dict[str, Any]]
+    filter_blocked_tools: Callable[..., dict[str, Any]]
+    normalize_tool_choice: Callable[..., dict[str, Any]]
+    write_context_usage: Callable[..., Any]
+    strip_advisor_tools: Callable[..., dict[str, Any]]
+    inject_channel_context: Callable[[dict[str, Any]], dict[str, Any]]
+    inject_tool_result_context: Callable[[dict[str, Any]], dict[str, Any]]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIResponsesRouting:
+    maybe_import_session: Callable[..., bool]
+    codex_routed_enabled: Callable[[str, dict[str, Any]], bool]
+    forward_codex: Callable[..., Any]
+    select_protocol: Callable[[str, dict[str, Any], str, str | None], str]
+    forward_provider_responses: Callable[..., dict[str, Any]]
+    dump_request: Callable[..., Any]
+    normalize_provider_wire: Callable[..., dict[str, Any]]
+    collect_message: Callable[..., dict[str, Any]]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIResponsesDelivery:
+    begin: Callable[..., Any]
+    mark_success: Callable[..., Any]
+    mark_failed: Callable[..., Any]
+    commit: Callable[..., Any]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIResponsesOutput:
+    write_response: Callable[..., Any]
+    write_error: Callable[..., Any]
+    upstream_error_message: Callable[..., str]
+    codex_auth_error_message: Callable[[str], str]
+    event_preview: Callable[..., dict[str, Any]]
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIResponsesServices:
+    core: OpenAIResponsesCore
+    conversion: OpenAIResponsesConversion
+    routing: OpenAIResponsesRouting
+    delivery: OpenAIResponsesDelivery
+    output: OpenAIResponsesOutput
+
+
+def handle_openai_responses_request(
+    handler: Any,
+    cfg: dict[str, Any],
+    provider: str,
+    pcfg: dict[str, Any],
+    body: dict[str, Any],
+    services: OpenAIResponsesServices,
+) -> None:
+    core = services.core
+    conversion = services.conversion
+    routing = services.routing
+    delivery = services.delivery
+    output = services.output
+    anthropic_body = conversion.to_anthropic(body, conversion.current_alias(cfg))
+    if routing.maybe_import_session(
+        handler,
+        anthropic_body,
+        client_runtime="codex",
+        response_format="openai",
+        source_body=body,
+    ):
+        return
+    if routing.codex_routed_enabled(provider, pcfg):
+        _handle_codex_route(handler, provider, pcfg, body, services)
+        return
+    if (
+        routing.select_protocol(
+            provider,
+            pcfg,
+            "openai_responses",
+            str(body.get("model") or ""),
+        )
+        == "openai_responses"
+    ):
+        _handle_provider_responses_route(
+            handler,
+            provider,
+            pcfg,
+            body,
+            services,
+        )
+        return
+
+    stream = bool(body.get("stream", True))
+    conversion.update_tool_schema(anthropic_body.get("tools"))
+    anthropic_body = conversion.normalize_thinking(provider, pcfg, anthropic_body)
+    request_id = core.request_id()
+    core.event_bus.publish(
+        level="info",
+        category="router.request",
+        message="OpenAI Responses request received",
+        request_id=request_id,
+        provider=provider,
+        model=str(anthropic_body.get("model") or ""),
+        data={
+            "path": "/v1/responses",
+            "messages": len(anthropic_body.get("messages") or []),
+            "tools": len(anthropic_body.get("tools") or []),
+            **output.event_preview(anthropic_body, cfg),
+        },
+    )
+    routing.dump_request(provider, "/v1/responses", body)
+    anthropic_body = conversion.filter_blocked_tools(provider, pcfg, anthropic_body)
+    anthropic_body = conversion.normalize_tool_choice(provider, pcfg, anthropic_body)
+    conversion.write_context_usage(provider, pcfg, anthropic_body, "responses")
+    anthropic_body = conversion.strip_advisor_tools(provider, anthropic_body)
+    anthropic_body = conversion.inject_channel_context(anthropic_body)
+    anthropic_body = conversion.inject_tool_result_context(anthropic_body)
+    delivery.begin(handler, anthropic_body)
+    anthropic_body = routing.normalize_provider_wire(provider, pcfg, anthropic_body)
+    core.log(
+        "DEBUG",
+        f"POST /v1/responses provider={provider} model={anthropic_body.get('model')} "
+        f"tools={len(anthropic_body.get('tools') or [])} msgs={len(anthropic_body.get('messages') or [])}",
+    )
+    try:
+        message = routing.collect_message(handler, provider, pcfg, anthropic_body)
+        output.write_response(handler, message, source_body=body, stream=stream)
+        delivery.mark_success(handler, "responses_json")
+        delivery.commit(anthropic_body, handler)
+    except urllib.error.HTTPError as exc:
+        raw = exc.read().decode("utf-8", errors="ignore")
+        delivery.mark_failed(handler, f"responses_http_error:{exc.code}")
+        output.write_error(handler, output.upstream_error_message(exc, raw), stream=stream, status=exc.code)
+    except Exception as exc:
+        if core.is_client_disconnect(exc):
+            delivery.mark_failed(handler, f"responses_client_disconnected:{type(exc).__name__}")
+            return
+        core.event_bus.publish(
+            level="error",
+            category="router.error",
+            message=str(exc),
+            request_id=request_id,
+            provider=provider,
+            model=str(anthropic_body.get("model") or ""),
+            data={"error_type": type(exc).__name__},
+        )
+        delivery.mark_failed(handler, f"responses_error:{type(exc).__name__}")
+        output.write_error(handler, f"{type(exc).__name__}: {exc}", stream=stream)
+
+
+def _handle_codex_route(
+    handler: Any,
+    provider: str,
+    pcfg: dict[str, Any],
+    body: dict[str, Any],
+    services: OpenAIResponsesServices,
+) -> None:
+    core = services.core
+    routing = services.routing
+    delivery = services.delivery
+    output = services.output
+    request_id = core.request_id()
+    core.event_bus.publish(
+        level="info",
+        category="router.request",
+        message="Codex Responses request received",
+        request_id=request_id,
+        provider=provider,
+        model=str(body.get("model") or ""),
+        data={
+            "path": urllib.parse.urlparse(handler.path).path,
+            "input_items": len(core.input_as_list(body.get("input", []))),
+            "tools": len(body.get("tools") or []),
+        },
+    )
+    routing.dump_request(provider, urllib.parse.urlparse(handler.path).path, body)
+    try:
+        routing.forward_codex(handler, provider, pcfg, body)
+    except urllib.error.HTTPError as exc:
+        raw = exc.read().decode("utf-8", errors="ignore")
+        delivery.mark_failed(handler, f"codex_responses_http_error:{exc.code}")
+        message = output.upstream_error_message(exc, raw)
+        if exc.code in (401, 403):
+            message = output.codex_auth_error_message(message)
+        output.write_error(handler, message, stream=bool(body.get("stream", True)), status=exc.code)
+    except Exception as exc:
+        if core.is_client_disconnect(exc):
+            delivery.mark_failed(handler, f"codex_responses_client_disconnected:{type(exc).__name__}")
+            return
+        delivery.mark_failed(handler, f"codex_responses_error:{type(exc).__name__}")
+        output.write_error(handler, f"{type(exc).__name__}: {exc}", stream=bool(body.get("stream", True)))
+
+
+def _handle_provider_responses_route(
+    handler: Any,
+    provider: str,
+    pcfg: dict[str, Any],
+    body: dict[str, Any],
+    services: OpenAIResponsesServices,
+) -> None:
+    core = services.core
+    routing = services.routing
+    delivery = services.delivery
+    output = services.output
+    request_id = core.request_id()
+    core.event_bus.publish(
+        level="info",
+        category="router.request",
+        message="Native provider Responses request received",
+        request_id=request_id,
+        provider=provider,
+        model=str(body.get("model") or ""),
+        data={
+            "path": urllib.parse.urlparse(handler.path).path,
+            "input_items": len(core.input_as_list(body.get("input", []))),
+            "tools": len(body.get("tools") or []),
+        },
+    )
+    routing.dump_request(
+        provider,
+        urllib.parse.urlparse(handler.path).path,
+        body,
+    )
+    try:
+        delivery_body = routing.forward_provider_responses(
+            handler,
+            provider,
+            pcfg,
+            body,
+        )
+        delivery.mark_success(handler, "provider_responses_proxy")
+        delivery.commit(delivery_body, handler)
+    except urllib.error.HTTPError as exc:
+        raw = exc.read().decode("utf-8", errors="ignore")
+        delivery.mark_failed(
+            handler,
+            f"provider_responses_http_error:{exc.code}",
+        )
+        output.write_error(
+            handler,
+            output.upstream_error_message(exc, raw),
+            stream=bool(body.get("stream", True)),
+            status=exc.code,
+        )
+    except Exception as exc:
+        if core.is_client_disconnect(exc):
+            delivery.mark_failed(
+                handler,
+                f"provider_responses_client_disconnected:{type(exc).__name__}",
+            )
+            return
+        core.event_bus.publish(
+            level="error",
+            category="router.error",
+            message=str(exc),
+            request_id=request_id,
+            provider=provider,
+            model=str(body.get("model") or ""),
+            data={"error_type": type(exc).__name__},
+        )
+        delivery.mark_failed(
+            handler,
+            f"provider_responses_error:{type(exc).__name__}",
+        )
+        output.write_error(
+            handler,
+            f"{type(exc).__name__}: {exc}",
+            stream=bool(body.get("stream", True)),
+        )

package/ciel_runtime_support/openai_responses_stream.py

@@ -0,0 +1,135 @@
+"""HTTP/SSE transport projection for OpenAI Responses payloads."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIResponsesStreamServices:
+    to_response: Callable[..., dict[str, Any]]
+    write_json: Callable[..., Any]
+
+
+def write_openai_responses(
+    handler: Any,
+    message: dict[str, Any],
+    source_body: dict[str, Any] | None,
+    *,
+    stream: bool,
+    services: OpenAIResponsesStreamServices,
+) -> None:
+    response = services.to_response(message, source_body=source_body)
+    if not stream:
+        services.write_json(handler, response)
+        return
+    _start_sse(handler, 200)
+    _emit(handler, "response.created", {"type": "response.created", "response": {**response, "status": "in_progress", "output": []}})
+    for output_index, item in enumerate(response.get("output") or []):
+        _emit_output_item(handler, response, output_index, item)
+    _emit(handler, "response.completed", {"type": "response.completed", "response": response})
+    handler.wfile.flush()
+
+
+def write_openai_responses_error(
+    handler: Any,
+    message: str,
+    *,
+    stream: bool,
+    status: int,
+    services: OpenAIResponsesStreamServices,
+) -> None:
+    payload = {"type": "error", "error": {"type": "api_error", "message": message}}
+    if not stream:
+        services.write_json(handler, payload, status)
+        return
+    _start_sse(handler, status)
+    _emit(handler, "error", payload)
+    handler.wfile.flush()
+
+
+def _emit_output_item(
+    handler: Any,
+    response: dict[str, Any],
+    output_index: int,
+    item: dict[str, Any],
+) -> None:
+    item_added = {**item}
+    if item_added.get("type") == "message":
+        item_added["content"] = []
+    _emit(
+        handler,
+        "response.output_item.added",
+        {
+            "type": "response.output_item.added",
+            "response_id": response["id"],
+            "output_index": output_index,
+            "item": item_added,
+        },
+    )
+    if item.get("type") == "message":
+        _emit_message_content(handler, response, output_index, item)
+    _emit(
+        handler,
+        "response.output_item.done",
+        {
+            "type": "response.output_item.done",
+            "response_id": response["id"],
+            "output_index": output_index,
+            "item": item,
+        },
+    )
+
+
+def _emit_message_content(
+    handler: Any,
+    response: dict[str, Any],
+    output_index: int,
+    item: dict[str, Any],
+) -> None:
+    content = item.get("content") if isinstance(item.get("content"), list) else []
+    for content_index, part in enumerate(content):
+        if not isinstance(part, dict) or part.get("type") != "output_text":
+            continue
+        common = {
+            "response_id": response["id"],
+            "item_id": item["id"],
+            "output_index": output_index,
+            "content_index": content_index,
+        }
+        _emit(
+            handler,
+            "response.content_part.added",
+            {"type": "response.content_part.added", **common, "part": {**part, "text": ""}},
+        )
+        text = str(part.get("text") or "")
+        if text:
+            _emit(
+                handler,
+                "response.output_text.delta",
+                {"type": "response.output_text.delta", **common, "delta": text},
+            )
+        _emit(
+            handler,
+            "response.output_text.done",
+            {"type": "response.output_text.done", **common, "text": text},
+        )
+        _emit(
+            handler,
+            "response.content_part.done",
+            {"type": "response.content_part.done", **common, "part": part},
+        )
+
+
+def _start_sse(handler: Any, status: int) -> None:
+    handler.send_response(status)
+    handler.send_header("content-type", "text/event-stream")
+    handler.send_header("cache-control", "no-cache")
+    handler.send_header("connection", "close")
+    handler.end_headers()
+
+
+def _emit(handler: Any, event_name: str, payload: dict[str, Any]) -> None:
+    handler.wfile.write(f"event: {event_name}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n".encode())