| from __future__ import annotations |
|
|
| import json |
| from typing import Any |
|
|
|
|
| def extract_tool_actions(text: str) -> list[dict[str, Any]]: |
| parsed = extract_json_value(text) |
| if isinstance(parsed, dict): |
| if "actions" in parsed: |
| raw_actions = parsed["actions"] |
| elif "tool_calls" in parsed: |
| raw_actions = parsed["tool_calls"] |
| else: |
| raw_actions = [parsed] |
| elif isinstance(parsed, list): |
| raw_actions = parsed |
| else: |
| raise ValueError("tool call JSON must be an object or array") |
|
|
| if not isinstance(raw_actions, list) or not raw_actions: |
| raise ValueError("actions must be a non-empty array") |
|
|
| actions: list[dict[str, Any]] = [] |
| for index, raw_action in enumerate(raw_actions, start=1): |
| if not isinstance(raw_action, dict): |
| raise ValueError(f"action #{index} must be an object") |
| actions.append(normalize_tool_action(raw_action)) |
| return actions |
|
|
|
|
| def normalize_tool_action(raw_action: dict[str, Any]) -> dict[str, Any]: |
| if "function" in raw_action and isinstance(raw_action["function"], dict): |
| function = raw_action["function"] |
| return normalize_named_tool_action(function.get("name"), function.get("arguments", {})) |
| if "tool" in raw_action or "name" in raw_action: |
| return normalize_named_tool_action( |
| raw_action.get("tool", raw_action.get("name")), |
| raw_action.get("arguments", {}), |
| ) |
| if "action" in raw_action: |
| return dict(raw_action) |
| raise ValueError("action object must contain 'tool', 'name', 'function', or 'action'") |
|
|
|
|
| def normalize_named_tool_action(name: Any, arguments: Any) -> dict[str, Any]: |
| if not isinstance(name, str) or not name.strip(): |
| raise ValueError("tool name must be a non-empty string") |
| if isinstance(arguments, str): |
| try: |
| arguments = json.loads(arguments) if arguments.strip() else {} |
| except json.JSONDecodeError as exc: |
| raise ValueError(f"tool arguments are not valid JSON: {exc}") from exc |
| if arguments is None: |
| arguments = {} |
| if not isinstance(arguments, dict): |
| raise ValueError("tool arguments must be an object") |
| action = dict(arguments) |
| action["action"] = name.strip() |
| return action |
|
|
|
|
| def extract_json_value(text: str) -> Any: |
| stripped = strip_code_fence(text.strip()) |
| try: |
| return json.loads(stripped) |
| except json.JSONDecodeError: |
| return json.loads(find_first_json_value(stripped)) |
|
|
|
|
| def strip_code_fence(text: str) -> str: |
| if not text.startswith("```"): |
| return text |
| lines = text.splitlines() |
| if len(lines) >= 3 and lines[-1].strip() == "```": |
| return "\n".join(lines[1:-1]).strip() |
| return text |
|
|
|
|
| def find_first_json_value(text: str) -> str: |
| object_start = text.find("{") |
| array_start = text.find("[") |
| starts = [index for index in (object_start, array_start) if index != -1] |
| if not starts: |
| raise ValueError("no JSON object or array found") |
| start = min(starts) |
| opening = text[start] |
| closing = "}" if opening == "{" else "]" |
|
|
| depth = 0 |
| in_string = False |
| escaped = False |
| for index in range(start, len(text)): |
| char = text[index] |
| if in_string: |
| if escaped: |
| escaped = False |
| elif char == "\\": |
| escaped = True |
| elif char == '"': |
| in_string = False |
| continue |
|
|
| if char == '"': |
| in_string = True |
| elif char == opening: |
| depth += 1 |
| elif char == closing: |
| depth -= 1 |
| if depth == 0: |
| return text[start : index + 1] |
| raise ValueError("unterminated JSON value") |
|
|
