@oneciel-ai/claude-any 0.1.25 → 0.1.27

package/README.md

@@ -34,7 +34,7 @@ arguments through unchanged.
 
 Credits: One Ciel LLC
 
-Current version: `0.1.25`
+Current version: `0.1.27`
 
 ## Why This Exists
 
@@ -249,12 +249,24 @@ steps under that larger model's supervision.
 
 ## Changelog
 
+### 0.1.27
+
+- **Plan mode support for non-Anthropic providers**: the router now keeps
+  `EnterPlanMode` available and supports Claude Code Plan mode even when the
+  upstream model does not reliably choose that internal tool. Forced
+  `tool_choice=EnterPlanMode` is answered locally with a valid Anthropic
+  `tool_use`, and long implementation requests that receive only a short or
+  empty non-actionable text response are promoted to `EnterPlanMode` using
+  language-agnostic structure checks.
+- **Plan-mode self-tool handling**: unsupported Claude Code self-tools are
+  still stripped for non-Anthropic providers, but Plan-mode tools are handled
+  separately so planning can work instead of being disabled.
+
 ### 0.1.25
 
-- **Plan-mode guard + diagnostics**: non-Anthropic providers now strip Claude
-  Code self-tools such as `EnterPlanMode` before forwarding requests upstream.
-  Set `~/.config/claude-any/log-level` to `TRACE` to capture redacted request
-  and response summaries in `requests.jsonl` / `responses.jsonl`.
+- **Plan-mode diagnostics**: set `~/.config/claude-any/log-level` to `TRACE`
+  to capture redacted request and response summaries in `requests.jsonl` /
+  `responses.jsonl`.
 - **Headless agent chat service**: the router exposes a small HTTP control
   plane for sub coding agents. Agents can post messages, poll updates after
   the last seen message id, or wait on an SSE stream when they do not have

package/claude_any.py

@@ -80,7 +80,7 @@ PROVIDER_LABELS = {
     "self-hosted-nim": "Self Hosted NIM",
 }
 APP_NAME = "Claude Any"
-VERSION = "0.1.25"
+VERSION = "0.1.27"
 CREDITS = "Credits: One Ciel LLC"
 
 LOG_LEVELS = {"SILENT": 0, "ERROR": 1, "WARN": 2, "INFO": 3, "DEBUG": 4, "TRACE": 5}
@@ -98,8 +98,8 @@ _CHAT_NEXT_ID: int | None = None
 # Tools Claude Code injects into every model's tool list that misfire when called
 # by non-Anthropic models. See docs/notes from anthropics/claude-code issues
 # #25720, #29950 and Piebald-AI/claude-code-system-prompts for tool semantics.
+PLAN_MODE_SELF_TOOLS: tuple[str, ...] = ("EnterPlanMode", "ExitPlanMode")
 DEFAULT_BLOCKED_TOOLS_NON_ANTHROPIC: tuple[str, ...] = (
-    "EnterPlanMode",
     "EnterWorktree",
     "ExitWorktree",
     "TeamCreate",
@@ -1185,15 +1185,130 @@ def resolve_blocked_tools(provider: str, pcfg: dict[str, Any]) -> set[str]:
     return set(DEFAULT_BLOCKED_TOOLS_NON_ANTHROPIC)
 
 
+def forced_tool_choice_name(body: dict[str, Any]) -> str | None:
+    tool_choice = body.get("tool_choice") if isinstance(body.get("tool_choice"), dict) else None
+    if not tool_choice:
+        return None
+    if tool_choice.get("type") != "tool":
+        return None
+    name = tool_choice.get("name")
+    return name if isinstance(name, str) and name else None
+
+
+def tool_names_in_body(body: dict[str, Any]) -> set[str]:
+    names: set[str] = set()
+    tools = body.get("tools")
+    if not isinstance(tools, list):
+        return names
+    for tool in tools:
+        if isinstance(tool, dict) and isinstance(tool.get("name"), str):
+            names.add(tool["name"])
+    return names
+
+
+def synthetic_tool_use_response(model: str, tool_name: str, tool_input: dict[str, Any] | None = None) -> dict[str, Any]:
+    now = int(time.time() * 1000)
+    return {
+        "id": f"msg_claude_any_tool_{now}",
+        "type": "message",
+        "role": "assistant",
+        "model": model or "claude-any-router",
+        "content": [
+            {
+                "type": "tool_use",
+                "id": f"toolu_claude_any_{tool_name}_{now}",
+                "name": tool_name,
+                "input": tool_input or {},
+            }
+        ],
+        "stop_reason": "tool_use",
+        "stop_sequence": None,
+        "usage": {"input_tokens": 0, "output_tokens": 0},
+    }
+
+
+def has_tool(body: dict[str, Any], name: str) -> bool:
+    return name in tool_names_in_body(body)
+
+
+def latest_user_text(body: dict[str, Any]) -> str:
+    for message in reversed(body.get("messages") or []):
+        if not isinstance(message, dict) or message.get("role") != "user":
+            continue
+        return anthropic_content_to_text(message.get("content"))
+    return ""
+
+
+def likely_implementation_planning_request(text: str) -> bool:
+    normalized = re.sub(r"\s+", " ", text or "").strip()
+    if len(normalized) >= 120:
+        return True
+    # Multi-line prompts usually carry enough task structure that a one-line
+    # "I'll make a plan" style response is not a useful final answer.
+    non_empty_lines = [line for line in (text or "").splitlines() if line.strip()]
+    if len(non_empty_lines) >= 3 and len(normalized) >= 80:
+        return True
+    return False
+
+
+def non_actionable_short_response(text: str) -> bool:
+    normalized = re.sub(r"\s+", " ", text or "").strip()
+    if not normalized:
+        return True
+    # Language-agnostic: for a long implementation request, a short single-line
+    # text response with no tool call is not actionable. Do not inspect words.
+    if len(normalized) <= 80 and "\n" not in (text or ""):
+        return True
+    if len(normalized) <= 160 and "\n" not in (text or "") and not re.search(r"[`{};/\\\\]|https?://", normalized):
+        return True
+    return False
+
+
+def should_auto_enter_plan_mode(body: dict[str, Any], response_text: str, tool_calls: list[dict[str, Any]]) -> bool:
+    if tool_calls:
+        return False
+    if not has_tool(body, "EnterPlanMode"):
+        return False
+    if not non_actionable_short_response(response_text):
+        return False
+    return likely_implementation_planning_request(latest_user_text(body))
+
+
+def maybe_handle_plan_mode_tool_choice(handler: BaseHTTPRequestHandler, provider: str, body: dict[str, Any]) -> bool:
+    """Support Claude Code's forced Plan-mode entry without relying on upstream model behavior."""
+    if provider == "anthropic":
+        return False
+    name = forced_tool_choice_name(body)
+    if name != "EnterPlanMode":
+        return False
+    # Claude Code may force this tool when the user uses /plan or toggles Plan mode.
+    # Returning a valid tool_use locally is more reliable than asking arbitrary
+    # OpenAI/Ollama-compatible backends to select an internal Claude Code tool.
+    available = tool_names_in_body(body)
+    if available and name not in available:
+        return False
+    router_log("INFO", f"synthesized {name} tool_use for {provider} forced tool_choice")
+    write_json(handler, synthetic_tool_use_response(str(body.get("model") or ""), name))
+    return True
+
+
 def filter_blocked_tools(provider: str, pcfg: dict[str, Any], body: dict[str, Any]) -> dict[str, Any]:
     """Strip Claude-Code self-tools the upstream model shouldn't see (e.g. EnterPlanMode).
     Returns a (possibly new) body dict."""
-    tools = body.get("tools")
-    if not isinstance(tools, list) or not tools:
-        return body
     blocked = resolve_blocked_tools(provider, pcfg)
     if not blocked:
         return body
+    tools = body.get("tools")
+    tool_choice = body.get("tool_choice") if isinstance(body.get("tool_choice"), dict) else None
+    tool_choice_name = tool_choice.get("name") if tool_choice else None
+    must_drop_tool_choice = isinstance(tool_choice_name, str) and tool_choice_name in blocked
+    if not isinstance(tools, list) or not tools:
+        if not must_drop_tool_choice:
+            return body
+        new_body = dict(body)
+        new_body.pop("tool_choice", None)
+        router_log("WARN", f"removed blocked tool_choice for {provider}: {tool_choice_name}")
+        return new_body
     kept: list[Any] = []
     dropped: list[str] = []
     for tool in tools:
@@ -1203,10 +1318,18 @@ def filter_blocked_tools(provider: str, pcfg: dict[str, Any], body: dict[str, An
             continue
         kept.append(tool)
     if not dropped:
-        return body
+        if not must_drop_tool_choice:
+            return body
+        new_body = dict(body)
+        new_body.pop("tool_choice", None)
+        router_log("WARN", f"removed blocked tool_choice for {provider}: {tool_choice_name}")
+        return new_body
     router_log("INFO", f"filtered upstream tools for {provider}: {', '.join(sorted(set(dropped)))}")
     new_body = dict(body)
     new_body["tools"] = kept
+    if must_drop_tool_choice:
+        new_body.pop("tool_choice", None)
+        router_log("WARN", f"removed blocked tool_choice for {provider}: {tool_choice_name}")
     return new_body
 
 
@@ -2400,7 +2523,7 @@ def normalize_tool_arguments(tool_name: str, args: Any) -> dict[str, Any]:
     return {}
 
 
-def ollama_chat_to_anthropic(data: dict[str, Any], model: str) -> dict[str, Any]:
+def ollama_chat_to_anthropic(data: dict[str, Any], model: str, source_body: dict[str, Any] | None = None) -> dict[str, Any]:
     message = data.get("message") if isinstance(data.get("message"), dict) else {}
     content: list[dict[str, Any]] = []
     text = message.get("content") or ""
@@ -2435,6 +2558,9 @@ def ollama_chat_to_anthropic(data: dict[str, Any], model: str) -> dict[str, Any]
                 "input": fixed_input,
             }
         )
+    if source_body is not None and should_auto_enter_plan_mode(source_body, text, message.get("tool_calls") or []):
+        router_log("WARN", "auto-synthesized EnterPlanMode from short/empty upstream response")
+        return synthetic_tool_use_response(model, "EnterPlanMode")
     done_reason = data.get("done_reason")
     stop_reason = "tool_use" if any(block.get("type") == "tool_use" for block in content) else "end_turn"
     if done_reason == "length":
@@ -2578,7 +2704,7 @@ def _rebatch_anthropic_sse_text(handler: BaseHTTPRequestHandler, resp: Any) -> N
             pass
 
 
-def _ollama_stream_to_anthropic_sse(handler: BaseHTTPRequestHandler, resp: Any, model: str, word_chunking: bool = False, provider: str = "ollama") -> None:
+def _ollama_stream_to_anthropic_sse(handler: BaseHTTPRequestHandler, resp: Any, model: str, word_chunking: bool = False, provider: str = "ollama", source_body: dict[str, Any] | None = None) -> None:
     """Stream Ollama NDJSON /api/chat response as Anthropic SSE /v1/messages format."""
     handler.send_response(200)
     handler.send_header("content-type", "text/event-stream")
@@ -2588,6 +2714,7 @@ def _ollama_stream_to_anthropic_sse(handler: BaseHTTPRequestHandler, resp: Any,
     msg_id = f"msg_ollama_{int(time.time() * 1000)}"
     started = False
     text_started = False
+    text_suppressed_for_plan = False
     next_content_index = 0
     text_index: int | None = None
     text_so_far = ""
@@ -2632,6 +2759,10 @@ def _ollama_stream_to_anthropic_sse(handler: BaseHTTPRequestHandler, resp: Any,
             # Handle text content
             text_chunk = message.get("content") or ""
             if text_chunk:
+                if source_body is not None and not text_started and not tool_calls and should_auto_enter_plan_mode(source_body, text_so_far + text_chunk, []):
+                    text_so_far += text_chunk
+                    text_suppressed_for_plan = True
+                    continue
                 if not text_started:
                     text_started = True
                     text_index = next_content_index
@@ -2713,6 +2844,50 @@ def _ollama_stream_to_anthropic_sse(handler: BaseHTTPRequestHandler, resp: Any,
                 handler.wfile.write(f"event: content_block_delta\ndata: {json.dumps(delta_event, ensure_ascii=False)}\n\n".encode())
                 handler.wfile.flush()
         # Flush any remaining buffered text when word-chunking is active
+        if source_body is not None and should_auto_enter_plan_mode(source_body, text_so_far, tool_calls):
+            router_log("WARN", "auto-synthesized EnterPlanMode from short/empty upstream stream")
+            tool_calls.append({"function": {"name": "EnterPlanMode", "arguments": {}}})
+            tool_id = f"toolu_ollama_plan_{int(time.time() * 1000)}"
+            tool_index = next_content_index
+            next_content_index += 1
+            tool_indices.append(tool_index)
+            tool_event = {
+                "type": "content_block_start",
+                "index": tool_index,
+                "content_block": {
+                    "type": "tool_use",
+                    "id": tool_id,
+                    "name": "EnterPlanMode",
+                    "input": {},
+                },
+            }
+            handler.wfile.write(f"event: content_block_start\ndata: {json.dumps(tool_event, ensure_ascii=False)}\n\n".encode())
+            handler.wfile.flush()
+            delta_event = {
+                "type": "content_block_delta",
+                "index": tool_index,
+                "delta": {"type": "input_json_delta", "partial_json": "{}"},
+            }
+            handler.wfile.write(f"event: content_block_delta\ndata: {json.dumps(delta_event, ensure_ascii=False)}\n\n".encode())
+            handler.wfile.flush()
+        elif text_suppressed_for_plan and text_so_far:
+            text_started = True
+            text_index = next_content_index
+            next_content_index += 1
+            event = {
+                "type": "content_block_start",
+                "index": text_index,
+                "content_block": {"type": "text", "text": ""},
+            }
+            handler.wfile.write(f"event: content_block_start\ndata: {json.dumps(event, ensure_ascii=False)}\n\n".encode())
+            handler.wfile.flush()
+            event = {
+                "type": "content_block_delta",
+                "index": text_index,
+                "delta": {"type": "text_delta", "text": text_so_far},
+            }
+            handler.wfile.write(f"event: content_block_delta\ndata: {json.dumps(event, ensure_ascii=False)}\n\n".encode())
+            handler.wfile.flush()
         if word_chunking and text_started and text_buffer:
             to_flush, text_buffer = _split_word_buffer(text_buffer, force=True)
             if to_flush:
@@ -2817,7 +2992,7 @@ def forward_ollama_api_chat(handler: BaseHTTPRequestHandler, provider: str, pcfg
         # Check if Claude Code requested SSE streaming
         accept = handler.headers.get("accept", "")
         if "text/event-stream" in accept or stream_requested:
-            _ollama_stream_to_anthropic_sse(handler, resp, model, word_chunking=word_chunking, provider=provider)
+            _ollama_stream_to_anthropic_sse(handler, resp, model, word_chunking=word_chunking, provider=provider, source_body=body)
         else:
             # Non-SSE client but streaming from Ollama: collect full response
             chunks = []
@@ -2838,7 +3013,7 @@ def forward_ollama_api_chat(handler: BaseHTTPRequestHandler, provider: str, pcfg
                     continue
             if data is None:
                 data = {"message": {"content": ""}, "done": True, "done_reason": "end_turn"}
-            write_json(handler, ollama_chat_to_anthropic(data, model))
+            write_json(handler, ollama_chat_to_anthropic(data, model, source_body=body))
         return
     # Non-streaming fallback
     try:
@@ -2863,7 +3038,7 @@ def forward_ollama_api_chat(handler: BaseHTTPRequestHandler, provider: str, pcfg
             exc.code,
         )
         return
-    write_json(handler, ollama_chat_to_anthropic(data, model))
+    write_json(handler, ollama_chat_to_anthropic(data, model, source_body=body))
 
 
 class RouterHandler(BaseHTTPRequestHandler):
@@ -2917,6 +3092,8 @@ class RouterHandler(BaseHTTPRequestHandler):
             write_json(self, {"type": "error", "error": {"type": "not_found_error", "message": path}}, 404)
             return
         dump_request_for_trace(provider, path, body)
+        if maybe_handle_plan_mode_tool_choice(self, provider, body):
+            return
         body = filter_blocked_tools(provider, pcfg, body)
         router_log("DEBUG", f"POST {path} provider={provider} model={body.get('model')} tools={len(body.get('tools') or [])} msgs={len(body.get('messages') or [])}")
         try:

package/docs/README.ja.md

@@ -33,7 +33,7 @@ vLLM、NVIDIA hosted、self-hosted NIM を選択し、通常の Claude Code 引
 
 Credits: One Ciel LLC
 
-現在のバージョン: `0.1.25`
+現在のバージョン: `0.1.27`
 
 ## 作られた理由
 
@@ -224,9 +224,14 @@ Windows/Linux 管理、クリーンアップスクリプト、定期的なセキ
 
 ## 変更履歴
 
+### 0.1.27
+
+- **non-Anthropic provider の Plan mode 対応**: ルーターは `EnterPlanMode` を残し、上流モデルが Claude Code 内部の Plan tool を安定して選択できない場合でも Claude Code Plan mode へ移行できるようにします。`tool_choice=EnterPlanMode` が強制されたリクエストには、ルーターがローカルで有効な Anthropic `tool_use` を返します。長い実装リクエストに対して短い、または空の実行不能なテキストだけが返った場合は、言語に依存しない構造チェックで `EnterPlanMode` に昇格します。
+- **Plan-mode self-tool 処理**: 未対応の Claude Code self-tool は non-Anthropic provider では引き続き除去しますが、Plan-mode tool は別扱いにして planning 機能を無効化しません。
+
 ### 0.1.25
 
-- **Plan mode guard と診断**: non-Anthropic provider へ転送する前に、Claude Code 内部 self-tool の `EnterPlanMode` などをルーターで除去します。`~/.config/claude-any/log-level` に `TRACE` を書くと、`requests.jsonl` / `responses.jsonl` にリクエスト/レスポンス要約を記録します。
+- **Plan mode 診断**: `~/.config/claude-any/log-level` に `TRACE` を書くと、`requests.jsonl` / `responses.jsonl` にリクエスト/レスポンス要約を記録します。
 - **ヘッドレスエージェントチャット**: ルーターが `/ca/chat/messages`、`/ca/chat/wait`、`/ca/chat/stream` を提供します。サブ coding agent は最後に見た message id 以降の更新を取得したり、SSE で返信を待機できます。
 - **Plan artifact 配信**: `/ca/plan/artifacts` で plan ファイルを作成し、ローカル URL として共有できます。Anthropic の内部実装はコピーせず、ファイル/アーティファクト中心の流れだけを独立実装しています。
 

package/docs/README.ko.md

@@ -33,7 +33,7 @@ NVIDIA hosted, self-hosted NIM을 선택하고, Claude Code의 일반 인자는
 
 Credits: One Ciel LLC
 
-현재 버전: `0.1.25`
+현재 버전: `0.1.27`
 
 ## 왜 만들었나
 
@@ -224,9 +224,14 @@ Windows 이벤트 로그 리뷰, 바이러스/랜섬웨어 침입 시도 정리,
 
 ## 변경 이력
 
+### 0.1.27
+
+- **non-Anthropic provider의 Plan mode 지원**: 라우터가 `EnterPlanMode`를 유지하고, 업스트림 모델이 Claude Code 내부 Plan tool을 안정적으로 선택하지 못해도 Claude Code Plan mode로 전환할 수 있게 처리합니다. `tool_choice=EnterPlanMode`가 강제된 요청은 라우터가 로컬에서 유효한 Anthropic `tool_use`로 응답하고, 긴 구현 요청에 대해 짧거나 빈 비실행 텍스트만 돌아오면 언어에 의존하지 않는 구조 검사로 `EnterPlanMode`로 승격합니다.
+- **Plan-mode self-tool 처리**: 지원하지 않는 Claude Code self-tool은 non-Anthropic provider에서 계속 제거하지만, Plan-mode tool은 별도 처리하여 planning 기능을 비활성화하지 않습니다.
+
 ### 0.1.25
 
-- **Plan mode guard와 진단**: non-Anthropic provider로 보낼 때 Claude Code 내부 self-tool인 `EnterPlanMode` 등을 라우터에서 제거합니다. `~/.config/claude-any/log-level`에 `TRACE`를 쓰면 `requests.jsonl` / `responses.jsonl`에 요청/응답 요약이 남습니다.
+- **Plan mode 진단**: `~/.config/claude-any/log-level`에 `TRACE`를 쓰면 `requests.jsonl` / `responses.jsonl`에 요청/응답 요약이 남습니다.
 - **헤드리스 에이전트 채팅**: 라우터가 `/ca/chat/messages`, `/ca/chat/wait`, `/ca/chat/stream`을 제공합니다. 서브 코딩 에이전트는 마지막 message id 이후의 업데이트를 받거나 SSE로 답변을 기다릴 수 있습니다.
 - **Plan artifact 서빙**: `/ca/plan/artifacts`로 plan 파일을 만들고 로컬 URL로 공유할 수 있습니다. Anthropic 내부 구현을 복제하지 않고 파일/아티팩트 중심 흐름만 독립 구현했습니다.
 

package/docs/README.zh.md

@@ -33,7 +33,7 @@ NIM，并把普通 Claude Code 参数原样传递。
 
 Credits: One Ciel LLC
 
-当前版本: `0.1.25`
+当前版本: `0.1.27`
 
 ## 为什么存在
 
@@ -212,9 +212,14 @@ Hermes 格式模型或部分较旧的 Qwen tool template。
 
 ## 更新日志
 
+### 0.1.27
+
+- **支持 non-Anthropic provider 的 Plan mode**: 路由器会保留 `EnterPlanMode`，即使上游模型不能稳定选择 Claude Code 内部 Plan tool，也能让 Claude Code 进入 Plan mode。对于强制 `tool_choice=EnterPlanMode` 的请求，路由器会在本地返回有效的 Anthropic `tool_use`。当较长的实现请求只得到很短或空的、不可执行的文本响应时，路由器会通过不依赖语言的结构检查将其提升为 `EnterPlanMode`。
+- **Plan-mode self-tool 处理**: 不支持的 Claude Code self-tool 在 non-Anthropic provider 下仍会被移除，但 Plan-mode tool 会单独处理，不再禁用 planning 能力。
+
 ### 0.1.25
 
-- **Plan mode guard 与诊断**: 转发到 non-Anthropic provider 前，路由器会移除 Claude Code 内部 self-tool，例如 `EnterPlanMode`。将 `TRACE` 写入 `~/.config/claude-any/log-level` 后，会在 `requests.jsonl` / `responses.jsonl` 中记录请求/响应摘要。
+- **Plan mode 诊断**: 将 `TRACE` 写入 `~/.config/claude-any/log-level` 后，会在 `requests.jsonl` / `responses.jsonl` 中记录请求/响应摘要。
 - **Headless agent chat**: 路由器提供 `/ca/chat/messages`、`/ca/chat/wait`、`/ca/chat/stream`。子 coding agent 可以按最后看到的 message id 拉取更新，也可以通过 SSE 等待回复。
 - **Plan artifact 服务**: 可通过 `/ca/plan/artifacts` 创建 plan 文件并以本地 URL 分享。这里没有复制 Anthropic 的内部实现，只独立实现了文件/artifact 型工作流。
 

package/docs/manual.md

@@ -6,7 +6,7 @@ Code starts, while passing normal Claude Code arguments through unchanged.
 
 Credits: One Ciel LLC
 
-Current version: `0.1.25`
+Current version: `0.1.27`
 
 ## Install
 
@@ -381,13 +381,18 @@ Notes for automation:
 
 ## Router Chat and Plan Artifacts
 
-Claude Code Plan mode uses internal Claude Code tools and UI state. With
-non-Anthropic providers those self-tools can be selected by the upstream model
-and leave the CLI stuck in planning instead of continuing work. Claude Any
-therefore removes known Claude Code self-tools, including `EnterPlanMode`,
-before forwarding requests to non-Anthropic providers. For troubleshooting,
-write `TRACE` to `~/.config/claude-any/log-level`; the router then records
-redacted request and response summaries in:
+Claude Code Plan mode uses internal Claude Code tools and UI state. Claude Any
+keeps `EnterPlanMode` available for non-Anthropic providers and handles the
+Plan-mode transition in the router when the upstream model does not reliably
+select that internal tool. If Claude Code forces `tool_choice=EnterPlanMode`,
+the router returns a valid Anthropic `tool_use` locally. If a long
+implementation request receives only a short or empty non-actionable text
+response, the router promotes that response to `EnterPlanMode` using
+language-agnostic structure checks. Other unsupported Claude Code self-tools
+are still removed before forwarding requests to non-Anthropic providers.
+
+For troubleshooting, write `TRACE` to `~/.config/claude-any/log-level`; the
+router then records redacted request and response summaries in:
 
 - `~/.config/claude-any/requests.jsonl`
 - `~/.config/claude-any/responses.jsonl`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oneciel-ai/claude-any",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "Claude Code provider selector for Anthropic, Ollama, Ollama Cloud, vLLM, NVIDIA hosted, and self-hosted NIM.",
   "license": "MIT",
   "author": "One Ciel LLC",