@oneciel-ai/ciel-runtime 0.2.22 → 0.2.23

package/ciel_runtime_support/channel_message_prompt.py

@@ -497,3 +497,18 @@ def format_llm_delivery_wake_prompt(messages: list[dict[str, Any]]) -> str:
     ids = [str(message.get("id") or "").strip() for message in messages]
     ids = [message_id for message_id in ids if message_id]
     return f"[ciel-wake] pending_ids={','.join(ids) or '-'}"
+
+
+def format_visible_llm_delivery_wake_prompt(
+    messages: list[dict[str, Any]],
+) -> str:
+    """Show a Codex wake body while retaining router replacement semantics.
+
+    The marker must remain the first physical line: conversation-turn policy
+    recognizes that prefix and removes the entire terminal-originated message
+    before the queued body is appended to the routed model request.
+    """
+
+    marker = format_llm_delivery_wake_prompt(messages)
+    body = format_llm_batch_prompt(messages)
+    return f"{marker}\n\n{body}" if body else marker

package/ciel_runtime_support/channel_pending_injection.py

@@ -31,6 +31,7 @@ class ChannelInjectionState:
 @dataclass(frozen=True, slots=True)
 class ChannelInjectionPrompts:
     llm_delivery: Callable[..., str]
+    visible_llm_delivery: Callable[..., str]
     web_chat: Callable[..., str]
     standard: Callable[..., str]
     enter_bytes: Callable[..., bytes]
@@ -87,6 +88,7 @@ def inject_pending_channel_messages(
     *,
     web_chat_only: bool = False,
     wake_for_llm_delivery: bool = False,
+    display_llm_delivery_body: bool = False,
     commit_cursor: bool = True,
     injected_message_ids: list[int] | None = None,
     submit_retry_count: int = 1,
@@ -170,7 +172,12 @@ def inject_pending_channel_messages(
                 io.log("INFO", f"channel_stdin_proxy_skipped_noise message_id={message_id} channel={channel} reason=duplicate_channel_event")
                 continue
             if candidate_uses_router:
-                message_prompt = prompts.llm_delivery([message])
+                formatter = (
+                    prompts.visible_llm_delivery
+                    if display_llm_delivery_body
+                    else prompts.llm_delivery
+                )
+                message_prompt = formatter([message])
             elif web_chat_only and state.message_is_web_chat(message):
                 message_prompt = prompts.web_chat([message])
             else:
@@ -228,7 +235,12 @@ def inject_pending_channel_messages(
         if not pending:
             return last_id
         if pending_uses_router:
-            prompt = prompts.llm_delivery(pending)
+            formatter = (
+                prompts.visible_llm_delivery
+                if display_llm_delivery_body
+                else prompts.llm_delivery
+            )
+            prompt = formatter(pending)
         elif web_chat_only and all(state.message_is_web_chat(message) for message in pending):
             prompt = prompts.web_chat(pending)
         else:
@@ -245,7 +257,7 @@ def inject_pending_channel_messages(
                 claimed_ids.append(claim_id)
         submit_bytes = prompts.enter_bytes(enter_bytes)
         try:
-            io.write_prompt(
+            submitted = io.write_prompt(
                 master_fd,
                 prompt,
                 submit_bytes,
@@ -254,6 +266,15 @@ def inject_pending_channel_messages(
                 bracketed_paste=bracketed_paste,
                 submit_delay_seconds=submit_delay_seconds,
             )
+            if submitted is False:
+                wake_store.rollback(pending, claimed_ids)
+                ids = ",".join(str(message.get("id") or "") for message in pending)
+                io.log(
+                    "WARN",
+                    "channel_stdin_proxy_deferred "
+                    f"message_ids={ids} reason=prompt_not_submitted",
+                )
+                return return_last_id if pending_uses_router else previous_last_id
             wake_store.record_prompts(pending, prompt)
         except Exception:
             wake_store.rollback(pending, claimed_ids)
@@ -267,6 +288,9 @@ def inject_pending_channel_messages(
         channels = ",".join(sorted({str(message.get("channel") or "default") for message in pending}))
         io.log(
             "INFO",
-            f"channel_stdin_proxy_injected count={len(pending)} message_ids={ids} channels={channels} enter={prompts.enter_label(submit_bytes)} commit_cursor={commit_cursor}",
+            f"channel_stdin_proxy_injected count={len(pending)} message_ids={ids} "
+            f"channels={channels} enter={prompts.enter_label(submit_bytes)} "
+            f"commit_cursor={commit_cursor} "
+            f"display_body={bool(pending_uses_router and display_llm_delivery_body)}",
         )
         return return_last_id if pending_uses_router else last_id

package/ciel_runtime_support/channel_pending_poll.py

@@ -66,6 +66,7 @@ class ChannelPendingInjectionOptions:
     enabled: bool
     web_chat_only: bool
     wake_for_llm_delivery: bool
+    display_llm_delivery_body: bool
     submit_retry_count: int
     confirm_submit: bool
     bracketed_paste: bool
@@ -138,6 +139,7 @@ def poll_pending_channel_messages(
         enter_bytes,
         web_chat_only=options.web_chat_only,
         wake_for_llm_delivery=options.wake_for_llm_delivery,
+        display_llm_delivery_body=options.display_llm_delivery_body,
         commit_cursor=False,
         injected_message_ids=injected_ids,
         submit_retry_count=options.submit_retry_count,

package/ciel_runtime_support/channel_terminal_context.py

@@ -212,6 +212,7 @@ class ChannelTerminalContext:
         inject_channel_messages: bool = True,
         inject_web_chat_only: bool = False,
         wake_for_llm_delivery: bool = False,
+        channel_wake_display_body: bool = False,
         synthetic_enter_bytes: str | bytes | None = None,
         normalize_bare_cr_for_synthetic_enter: bool = True,
         channel_wake_submit_retries: int = 1,
@@ -228,6 +229,7 @@ class ChannelTerminalContext:
             inject_channel_messages=inject_channel_messages,
             inject_web_chat_only=inject_web_chat_only,
             wake_for_llm_delivery=wake_for_llm_delivery,
+            channel_wake_display_body=channel_wake_display_body,
             synthetic_enter_bytes=synthetic_enter_bytes,
             normalize_bare_cr_for_synthetic_enter=(
                 normalize_bare_cr_for_synthetic_enter
@@ -278,6 +280,7 @@ class ChannelTerminalCompatibilityApi:
         inject_channel_messages: bool = True,
         inject_web_chat_only: bool = False,
         wake_for_llm_delivery: bool = False,
+        channel_wake_display_body: bool = False,
         synthetic_enter_bytes: str | bytes | None = None,
         normalize_bare_cr_for_synthetic_enter: bool = True,
         channel_wake_submit_retries: int = 1,
@@ -292,6 +295,7 @@ class ChannelTerminalCompatibilityApi:
             inject_channel_messages=inject_channel_messages,
             inject_web_chat_only=inject_web_chat_only,
             wake_for_llm_delivery=wake_for_llm_delivery,
+            channel_wake_display_body=channel_wake_display_body,
             synthetic_enter_bytes=synthetic_enter_bytes,
             normalize_bare_cr_for_synthetic_enter=(
                 normalize_bare_cr_for_synthetic_enter
@@ -311,6 +315,7 @@ class ChannelTerminalCompatibilityApi:
         inject_channel_messages: bool = True,
         inject_web_chat_only: bool = False,
         wake_for_llm_delivery: bool = False,
+        channel_wake_display_body: bool = False,
         synthetic_enter_bytes: str | bytes | None = None,
         normalize_bare_cr_for_synthetic_enter: bool = True,
         channel_wake_submit_retries: int = 1,
@@ -325,6 +330,7 @@ class ChannelTerminalCompatibilityApi:
             inject_channel_messages=inject_channel_messages,
             inject_web_chat_only=inject_web_chat_only,
             wake_for_llm_delivery=wake_for_llm_delivery,
+            channel_wake_display_body=channel_wake_display_body,
             synthetic_enter_bytes=synthetic_enter_bytes,
             normalize_bare_cr_for_synthetic_enter=(
                 normalize_bare_cr_for_synthetic_enter

package/ciel_runtime_support/channel_terminal_dispatch.py

@@ -47,6 +47,7 @@ class ChannelTerminalDispatchService:
         inject_channel_messages: bool = True,
         inject_web_chat_only: bool = False,
         wake_for_llm_delivery: bool = False,
+        channel_wake_display_body: bool = False,
         synthetic_enter_bytes: str | bytes | None = None,
         normalize_bare_cr_for_synthetic_enter: bool = True,
         channel_wake_submit_retries: int = 1,
@@ -59,6 +60,7 @@ class ChannelTerminalDispatchService:
             "inject_channel_messages": inject_channel_messages,
             "inject_web_chat_only": inject_web_chat_only,
             "wake_for_llm_delivery": wake_for_llm_delivery,
+            "channel_wake_display_body": channel_wake_display_body,
             "synthetic_enter_bytes": synthetic_enter_bytes,
             "normalize_bare_cr_for_synthetic_enter": (
                 normalize_bare_cr_for_synthetic_enter

package/ciel_runtime_support/channel_terminal_proxy.py

@@ -122,6 +122,7 @@ def run_windows_channel_terminal_proxy(
     inject_channel_messages: bool = True,
     inject_web_chat_only: bool = False,
     wake_for_llm_delivery: bool = False,
+    channel_wake_display_body: bool = False,
     synthetic_enter_bytes: str | bytes | None = None,
     channel_wake_submit_retries: int = 1,
     channel_wake_confirm_submit: bool = False,
@@ -172,6 +173,7 @@ def run_windows_channel_terminal_proxy(
         enabled=inject_channel_messages,
         web_chat_only=inject_web_chat_only,
         wake_for_llm_delivery=wake_for_llm_delivery,
+        display_llm_delivery_body=channel_wake_display_body,
         submit_retry_count=submit_retry_count,
         confirm_submit=channel_wake_confirm_submit,
         bracketed_paste=windows_bracketed_paste,
@@ -194,7 +196,8 @@ def run_windows_channel_terminal_proxy(
         f"pid={proc.pid} transport={'conpty' if conpty is not None else 'console-input'} "
         f"enter={policy.enter_label(channel_enter_bytes)} "
         f"submit_retries={submit_retry_count} confirm_submit={bool(channel_wake_confirm_submit)} "
-        f"bracketed_paste={windows_bracketed_paste}",
+        f"bracketed_paste={windows_bracketed_paste} "
+        f"display_body={bool(channel_wake_display_body)}",
     )
     try:
         while proc.poll() is None:
@@ -308,6 +311,7 @@ def run_posix_channel_terminal_proxy(
     inject_channel_messages: bool = True,
     inject_web_chat_only: bool = False,
     wake_for_llm_delivery: bool = False,
+    channel_wake_display_body: bool = False,
     synthetic_enter_bytes: str | bytes | None = None,
     normalize_bare_cr_for_synthetic_enter: bool = True,
     channel_wake_submit_retries: int = 1,
@@ -353,6 +357,7 @@ def run_posix_channel_terminal_proxy(
         enabled=inject_channel_messages,
         web_chat_only=inject_web_chat_only,
         wake_for_llm_delivery=wake_for_llm_delivery,
+        display_llm_delivery_body=channel_wake_display_body,
         submit_retry_count=submit_retry_count,
         confirm_submit=channel_wake_confirm_submit,
         bracketed_paste=channel_wake_bracketed_paste,
@@ -372,7 +377,8 @@ def run_posix_channel_terminal_proxy(
         "channel_stdin_proxy_enter_default "
         f"enter={policy.enter_label(channel_enter_bytes)} os={os.name} platform={sys.platform} "
         f"submit_retries={submit_retry_count} confirm_submit={bool(channel_wake_confirm_submit)} "
-        f"bracketed_paste={bool(channel_wake_bracketed_paste)}",
+        f"bracketed_paste={bool(channel_wake_bracketed_paste)} "
+        f"display_body={bool(channel_wake_display_body)}",
     )
     terminal.reset_input_mode()
 

package/ciel_runtime_support/channel_wake_claim_repository.py

@@ -24,6 +24,13 @@ def prompt_contains(candidate: str, prompt: str) -> bool:
 
 
 def prompt_message_ids(text: str) -> set[int]:
+    normalized = re.sub(r"^[\x00-\x1f\x7f\s]+", "", str(text or ""))
+    if normalized.startswith("[ciel-wake]"):
+        # A visible Codex wake may contain an untrusted original body after
+        # the first line.  Only the trusted marker line owns correlation IDs;
+        # strings such as ``id=999`` in the external body must not claim an
+        # unrelated queued message.
+        text = normalized.splitlines()[0]
     ids: set[int] = set()
     for match in _PROMPT_IDS_RE.finditer(str(text or "")):
         for raw in re.split(r"\D+", match.group(1)):

package/ciel_runtime_support/channel_wake_context.py

@@ -129,6 +129,7 @@ class ChannelPendingStatePorts:
 @dataclass(frozen=True, slots=True)
 class ChannelPendingDeliveryPorts:
     format_llm_delivery: Callable[[list[dict[str, Any]]], str]
+    format_visible_llm_delivery: Callable[[list[dict[str, Any]]], str]
     format_web_chat: Callable[[list[dict[str, Any]]], str]
     format_standard: Callable[[list[dict[str, Any]]], str]
     enter_label: Callable[[bytes], str]
@@ -143,7 +144,7 @@ class ChannelPendingDeliveryPorts:
 class ChannelPendingIoPorts:
     inject_lock: Any
     read_messages: Callable[..., list[dict[str, Any]]]
-    write_prompt: Callable[..., None]
+    write_prompt: Callable[..., bool]
     compact_read: Callable[[], dict[str, Any] | None]
     compact_clear: Callable[[], None]
     messages_path: Path
@@ -331,7 +332,7 @@ class ChannelWakeContext:
         submit_delay_seconds: float | None = None,
         write_all: Callable[[Any, bytes], None] | None = None,
         snapshot: Callable[[], str | None] | None = None,
-    ) -> None:
+    ) -> bool:
         delay = (
             self.input.submit_delay_seconds()
             if submit_delay_seconds is None
@@ -343,7 +344,7 @@ class ChannelWakeContext:
             snapshot=snapshot or self.current_tmux_pane_text,
             log=self.input.log,
         )
-        injector.inject(
+        return injector.inject(
             channel_injection.CallableInputTransport(
                 master_fd, write_all or self.write_all
             ),
@@ -530,6 +531,9 @@ class ChannelWakeContext:
             ),
             prompts=ChannelInjectionPrompts(
                 llm_delivery=self.pending_delivery.format_llm_delivery,
+                visible_llm_delivery=(
+                    self.pending_delivery.format_visible_llm_delivery
+                ),
                 web_chat=self.pending_delivery.format_web_chat,
                 standard=self.pending_delivery.format_standard,
                 enter_bytes=self.enter_bytes,

package/ciel_runtime_support/cli_parser.py

@@ -34,6 +34,9 @@ class CliParserSettings:
     web_fetch: CliHandler
     log_level: CliHandler
     external_events: CliHandler
+    transcript_events: CliHandler
+    usage_events: CliHandler
+    usage_api_key: CliHandler
     remote_instructions: CliHandler
     remote_memory: CliHandler
 
@@ -91,6 +94,9 @@ def build_cli_parser(services: CliParserServices) -> argparse.ArgumentParser:
     _add_optional_value_command(commands, "web-fetch", services.settings.web_fetch)
     _add_optional_value_command(commands, "log-level", services.settings.log_level)
     _add_values_command(commands, "external-events", services.settings.external_events)
+    _add_values_command(commands, "transcript-events", services.settings.transcript_events)
+    _add_values_command(commands, "usage-events", services.settings.usage_events)
+    _add_values_command(commands, "usage-api-key", services.settings.usage_api_key)
     _add_values_command(commands, "remote-instructions", services.settings.remote_instructions)
     _add_values_command(commands, "remote-memory", services.settings.remote_memory)
     _add_optional_value_command(commands, "ollama-native", services.provider.ollama_native)

package/ciel_runtime_support/codex_backend_context.py

@@ -67,6 +67,8 @@ class ProviderPassthroughProjectionPorts:
     responses_request_max_bytes: Callable[[str, dict[str, Any]], int | None] = (
         lambda _provider, _config: None
     )
+    finalize_chat: Callable[[dict[str, Any]], dict[str, Any]] = lambda body: body
+    finalize_responses: Callable[[dict[str, Any]], dict[str, Any]] = lambda body: body
 
 
 @dataclass(frozen=True, slots=True)
@@ -249,6 +251,7 @@ class CodexBackendContext:
                 urlopen=self.provider_transport.urlopen,
                 timeout_seconds=self.provider_transport.timeout_seconds,
                 copy_response_headers=self.provider_transport.copy_response_headers,
+                finalize_body=self.provider_projection.finalize_chat,
             )
         )
 
@@ -279,6 +282,7 @@ class CodexBackendContext:
                 request_max_bytes=self.provider_projection.responses_request_max_bytes,
                 estimate_tokens=self.replay.estimate_tokens,
                 compact_responses=self.replay.compact_responses,
+                finalize_body=self.provider_projection.finalize_responses,
             )
         )
 

package/ciel_runtime_support/codex_turn_recovery.py

@@ -27,6 +27,13 @@ CODEX_EMPTY_REASONING_CONTINUATION_NUDGE = (
     "or provide the concrete final answer if no tool is needed."
 )
 
+CODEX_REPEATED_TOOL_CONTINUATION_NUDGE = (
+    "The runtime stopped an exact tool call because the same call and result are "
+    "already present twice in this turn. Do not repeat that call. Use the existing "
+    "result, choose a different action if one is required, or provide the concrete "
+    "final answer now."
+)
+
 RUNTIME_REASONING_ONLY_NOTICE_PREFIXES = (
     "[ciel-runtime] Upstream model returned reasoning without a final answer or tool call.",
     "[ciel-runtime] Upstream model exhausted its output budget during reasoning",
@@ -37,6 +44,13 @@ RUNTIME_EMPTY_END_TURN_NOTICE_PREFIX = (
     "tool call."
 )
 
+RUNTIME_REPEATED_TOOL_NOTICE_PREFIX = (
+    "[ciel-runtime] Stopped an identical completed tool call from repeating."
+)
+
+RUNTIME_CONTROL_MESSAGE_KEY = "ciel_runtime_control"
+RUNTIME_REPEATED_TOOL_RECOVERY = "repeated_tool_call_recovery"
+
 KIMI_FOLLOWUP_PROMISE_RE = re.compile(
     r"(?:겠습니다|할게요|해볼게요|하겠습니다|"
     r"i(?:'|’)ll\b[^\n]*|i\s+will\b[^\n]*|let\s+me\b[^\n]*)[.!?。！？]?\s*$",
@@ -97,6 +111,21 @@ def message_has_only_empty_end_turn_notice(message: dict[str, Any]) -> bool:
     )
 
 
+def message_has_only_repeated_tool_notice(message: dict[str, Any]) -> bool:
+    """Identify the runtime's internal repeated-tool guard projection."""
+
+    texts = [
+        str(block.get("text") or "").strip()
+        for block in message.get("content") or []
+        if isinstance(block, dict)
+        and block.get("type") == "text"
+        and str(block.get("text") or "").strip()
+    ]
+    return bool(texts) and all(
+        text.startswith(RUNTIME_REPEATED_TOOL_NOTICE_PREFIX) for text in texts
+    )
+
+
 def kimi_message_promises_followup(message: dict[str, Any]) -> bool:
     """Recognize Kimi ending a reasoning turn with an unperformed next action."""
 
@@ -129,8 +158,24 @@ def message_without_empty_end_turn_notice(message: dict[str, Any]) -> dict[str,
     return projected
 
 
+def message_without_repeated_tool_notice(message: dict[str, Any]) -> dict[str, Any]:
+    if not message_has_only_repeated_tool_notice(message):
+        return message
+    projected = dict(message)
+    projected["content"] = [
+        dict(block) if isinstance(block, dict) else block
+        for block in message.get("content") or []
+        if not (isinstance(block, dict) and block.get("type") == "text")
+    ]
+    return projected
+
+
 def body_with_continuation_nudge(
-    body: dict[str, Any], message: dict[str, Any], nudge: str = CODEX_CONTINUATION_NUDGE
+    body: dict[str, Any],
+    message: dict[str, Any],
+    nudge: str = CODEX_CONTINUATION_NUDGE,
+    *,
+    control: str | None = None,
 ) -> dict[str, Any]:
     """Replay the request with the stalled reply and an explicit continue turn."""
 
@@ -138,7 +183,10 @@ def body_with_continuation_nudge(
     assistant_text = message_text(message).strip()
     if assistant_text:
         messages.append({"role": "assistant", "content": [{"type": "text", "text": assistant_text}]})
-    messages.append({"role": "user", "content": [{"type": "text", "text": nudge}]})
+    continuation = {"role": "user", "content": [{"type": "text", "text": nudge}]}
+    if control:
+        continuation[RUNTIME_CONTROL_MESSAGE_KEY] = control
+    messages.append(continuation)
     retried = dict(body)
     retried["messages"] = messages
     return retried
@@ -197,9 +245,9 @@ def recover_preamble_only_turn(
         return message
     text = message_text(message)
     empty_end_turn = message_has_only_empty_end_turn_notice(message)
-    kimi_reasoning_only = (
-        (provider or "").strip().lower() == "kimi"
-        and message_has_reasoning(message)
+    repeated_tool_guard = message_has_only_repeated_tool_notice(message)
+    reasoning_only = (
+        message_has_reasoning(message)
         and (not text.strip() or message_has_only_reasoning_notice(message))
     )
     kimi_promised_followup = (
@@ -209,7 +257,8 @@ def recover_preamble_only_turn(
     )
     if (
         not empty_end_turn
-        and not kimi_reasoning_only
+        and not repeated_tool_guard
+        and not reasoning_only
         and not kimi_promised_followup
         and not services.should_retry(body, text, [])
     ):
@@ -218,8 +267,10 @@ def recover_preamble_only_turn(
     reason = (
         "empty_end_turn"
         if empty_end_turn
+        else "repeated_tool_call"
+        if repeated_tool_guard
         else "reasoning_only"
-        if kimi_reasoning_only
+        if reasoning_only
         else "promised_followup"
         if kimi_promised_followup
         else "preamble_only"
@@ -231,8 +282,11 @@ def recover_preamble_only_turn(
     )
     try:
         nudge = (
+            CODEX_REPEATED_TOOL_CONTINUATION_NUDGE
+            if repeated_tool_guard
+            else
             CODEX_EMPTY_REASONING_CONTINUATION_NUDGE
-            if empty_end_turn or kimi_reasoning_only
+            if empty_end_turn or reasoning_only
             else CODEX_CONTINUATION_NUDGE
         )
         recovery_config = dict(pcfg)
@@ -244,12 +298,15 @@ def recover_preamble_only_turn(
             recovery_config,
             body_with_continuation_nudge(
                 body,
-                message_without_empty_end_turn_notice(message)
+                message_without_repeated_tool_notice(message)
+                if repeated_tool_guard
+                else message_without_empty_end_turn_notice(message)
                 if empty_end_turn
                 else message_without_reasoning_notice(message)
-                if kimi_reasoning_only
+                if reasoning_only
                 else message,
                 nudge,
+                control=(RUNTIME_REPEATED_TOOL_RECOVERY if repeated_tool_guard else None),
             ),
         )
     except Exception as exc:  # noqa: BLE001 - recovery must never fail the turn
@@ -260,8 +317,11 @@ def recover_preamble_only_turn(
         return message
     if not isinstance(retried, dict):
         return message
-    if empty_end_turn or kimi_reasoning_only:
-        if not message_has_tool_use(retried) and not message_text(retried).strip():
+    if empty_end_turn or reasoning_only or repeated_tool_guard:
+        if (
+            message_has_only_repeated_tool_notice(retried)
+            or (not message_has_tool_use(retried) and not message_text(retried).strip())
+        ):
             return message
         return retried
     if not message_has_tool_use(retried):
@@ -286,6 +346,7 @@ def _merged(original: dict[str, Any], retried: dict[str, Any]) -> dict[str, Any]
 __all__ = [
     "CODEX_CONTINUATION_NUDGE",
     "CODEX_EMPTY_REASONING_CONTINUATION_NUDGE",
+    "CODEX_REPEATED_TOOL_CONTINUATION_NUDGE",
     "RUNTIME_EMPTY_END_TURN_NOTICE_PREFIX",
     "CodexTurnRecoveryServices",
     "body_with_codex_compat_instructions",
@@ -294,8 +355,10 @@ __all__ = [
     "message_has_reasoning",
     "message_has_only_reasoning_notice",
     "message_has_only_empty_end_turn_notice",
+    "message_has_only_repeated_tool_notice",
     "kimi_message_promises_followup",
     "message_without_empty_end_turn_notice",
+    "message_without_repeated_tool_notice",
     "message_without_reasoning_notice",
     "message_text",
     "recover_preamble_only_turn",

package/ciel_runtime_support/config_migrations.py

@@ -34,6 +34,52 @@ def apply_config_migrations(cfg: dict[str, Any], *, policy: ConfigMigrationPolic
         migrations = {}
         cfg["migrations"] = migrations
 
+    marker = "ox_alpha_provider_catalogs_20260823"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        additions = {
+            "openrouter": ("stealth/ox-alpha", None),
+            "opencode": ("x-preview-f-free", "openai-chat"),
+            "opencode-go": ("ox-alpha-free", "openai-chat"),
+        }
+        for provider_name, (model, endpoint) in additions.items():
+            pcfg = providers.get(provider_name)
+            if not isinstance(pcfg, dict):
+                continue
+            custom = pcfg.get("custom_models")
+            if not isinstance(custom, list):
+                custom = []
+                pcfg["custom_models"] = custom
+            known = {
+                normalize_model_id(provider_name, str(item))
+                for item in custom
+                if str(item).strip()
+            }
+            if normalize_model_id(provider_name, model) not in known:
+                custom.append(model)
+            if endpoint:
+                model_endpoints = pcfg.get("model_endpoints")
+                if not isinstance(model_endpoints, dict):
+                    model_endpoints = {}
+                    pcfg["model_endpoints"] = model_endpoints
+                model_endpoints.setdefault(model, endpoint)
+        migrations[marker] = True
+
+    marker = "opencode_catalog_protocol_refresh_20260823"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        zen = providers.get("opencode")
+        if isinstance(zen, dict):
+            custom = zen.get("custom_models")
+            if isinstance(custom, list):
+                zen["custom_models"] = [
+                    model
+                    for model in custom
+                    if normalize_model_id("opencode", str(model))
+                    != "qwen3.6-plus-free"
+                ]
+        migrations[marker] = True
+
     marker = "alibaba_provider_catalogs_20260806"
     if not migrations.get(marker):
         providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
@@ -73,6 +119,62 @@ def apply_config_migrations(cfg: dict[str, Any], *, policy: ConfigMigrationPolic
                     custom.append(model)
         migrations[marker] = True
 
+    marker = "alibaba_qwen38_singapore_20260821"
+    if not migrations.get(marker):
+        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
+        model_studio = providers.get("alims-intl")
+        if isinstance(model_studio, dict):
+            custom = model_studio.get("custom_models")
+            if not isinstance(custom, list):
+                custom = []
+                model_studio["custom_models"] = custom
+            known = {
+                normalize_model_id("alims-intl", str(model))
+                for model in custom
+                if str(model).strip()
+            }
+            if normalize_model_id("alims-intl", "qwen3.8-max") not in known:
+                custom.insert(0, "qwen3.8-max")
+            model_studio["region"] = "ap-southeast-1"
+            old_default_profile = (
+                normalize_model_id(
+                    "alims-intl", str(model_studio.get("current_model") or "")
+                )
+                == "qwen3.7-max"
+                and normalize_model_id(
+                    "alims-intl", str(model_studio.get("opus_model") or "")
+                )
+                == "qwen3.7-max"
+                and (positive_int(model_studio.get("max_output_tokens")) or 0) == 65_536
+                and str(model_studio.get("effort_level") or "").strip().lower()
+                == "high"
+            )
+            if old_default_profile:
+                model_studio.update(
+                    {
+                        "current_model": "qwen3.8-max",
+                        "opus_model": "qwen3.8-max",
+                        "context_window": 1_000_000,
+                        "max_model_len": 1_000_000,
+                        "max_output_tokens": 131_072,
+                        "effort_level": "xhigh",
+                    }
+                )
+        for provider_name in ("alitoken", "alitoken-individual"):
+            pcfg = providers.get(provider_name)
+            if not isinstance(pcfg, dict):
+                continue
+            selected = normalize_model_id(
+                provider_name, str(pcfg.get("current_model") or "")
+            )
+            if selected != "qwen3.8-max":
+                continue
+            if (positive_int(pcfg.get("context_window")) or 0) == 1_048_576:
+                pcfg["context_window"] = 1_000_000
+            if (positive_int(pcfg.get("max_model_len")) or 0) == 1_048_576:
+                pcfg["max_model_len"] = 1_000_000
+        migrations[marker] = True
+
     marker = "alibaba_token_plan_singapore_20260806"
     if not migrations.get(marker):
         providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
@@ -310,16 +412,6 @@ def apply_config_migrations(cfg: dict[str, Any], *, policy: ConfigMigrationPolic
 
     marker = "opencode_zen_qwen36_plus_free_model_20260614"
     if not migrations.get(marker):
-        providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
-        pcfg = providers.get("opencode")
-        if isinstance(pcfg, dict):
-            custom = pcfg.get("custom_models")
-            if not isinstance(custom, list):
-                custom = []
-                pcfg["custom_models"] = custom
-            normalized_custom = {normalize_model_id("opencode", str(mid)) for mid in custom if str(mid).strip()}
-            if "qwen3.6-plus-free" not in normalized_custom:
-                custom.append("qwen3.6-plus-free")
         migrations[marker] = True
 
     marker = "opencode_qwen36_plus_parameters_20260614"

package/ciel_runtime_support/config_repository.py

@@ -112,6 +112,15 @@ def build_default_config(provider_defaults: dict[str, Any]) -> dict[str, Any]:
         "web_backends": {},
         "workspace_mcp": {"servers": {}},
         "external_event_receivers": {},
+        "transcript_events": {
+            "enabled": False,
+            "url": "",
+            "authorization": "",
+            "timeout_seconds": 5,
+            "poll_interval_ms": 1000,
+            "max_batch_bytes": 1048576,
+            "start_mode": "tail",
+        },
         "remote_instructions": {
             "enabled": False,
             "claude_url": "",