LoCAL2 — Phase 1b

_execute_tool() implementation

_TOOL_REQUEST = {
    "web_search": TOOL_REQUEST_WEB_SEARCH,
    "web_fetch":  TOOL_REQUEST_WEB_FETCH,
}
_TOOL_RESULT = {
    "web_search": TOOL_RESULT_WEB_SEARCH,
    "web_fetch":  TOOL_RESULT_WEB_FETCH,
}

def _execute_tool(self, name: str, args: dict, correlation_id: str) -> str:
    req_subject = _TOOL_REQUEST.get(name)
    res_subject = _TOOL_RESULT.get(name)
    if not req_subject:
        return f"[unknown tool: {name!r}]"

    self._sm.transition(GeneratorAction.AWAIT_TOOL)   # DISPATCHING_TOOL → WAITING_FOR_TOOL

    sub = ZmqSubscriber(PROXY_BACKEND_ADDR, subscriptions=[res_subject], bind=False)
    try:
        self._pub.publish(self._make_envelope(
            req_subject, "tool_request",
            {"tool": name, "args": args,
             "session_id": None, "query_id": correlation_id},
            correlation_id, None,
        ))
        deadline = time.time() + self._tool_timeout
        while time.time() < deadline:
            msg = sub.receive_with_timeout(200)
            if msg and msg.correlation_id == correlation_id:
                p = msg.payload
                if p.get("error"):
                    self._sm.transition(GeneratorAction.TOOL_RESULT)
                    return f"[tool error: {p['error']}]"
                self._sm.transition(GeneratorAction.TOOL_RESULT)
                return p.get("result") or ""
    finally:
        sub.close()

    self._sm.transition(GeneratorAction.TOOL_TIMEOUT)
    logger.warning("tool %r timed out after %ss", name, self._tool_timeout)
    return f"[tool timeout after {self._tool_timeout}s]"

State machine update — add AWAIT_TOOL action + transition

# generator_actions.py — add:
AWAIT_TOOL = "await_tool"   # DISPATCHING_TOOL → WAITING_FOR_TOOL

# generator_transitions.py — add:
(S.DISPATCHING_TOOL, A.AWAIT_TOOL):   S.WAITING_FOR_TOOL,

# Existing transitions already cover result/timeout back to GENERATING:
# (S.WAITING_FOR_TOOL, A.TOOL_RESULT):  S.GENERATING  ← already present
# (S.WAITING_FOR_TOOL, A.TOOL_TIMEOUT): S.GENERATING  ← already present
# (S.WAITING_FOR_TOOL, A.FAIL):         S.ERROR        ← already present (via FAIL loop)

For multiple tool calls in one response, the outer loop re-enters DISPATCHING_TOOL between each call. The _generate() outer loop transitions back to DISPATCHING_TOOL before calling _execute_tool() for the next tool.

_generate() outer loop — updated transitions

self._sm.transition(GeneratorAction.DISPATCH_TOOL)   # GENERATING → DISPATCHING_TOOL
for tc in tool_calls:
    fn = tc.get("function") or {}
    name = fn.get("name", "")
    args = fn.get("arguments") or {}
    result = self._execute_tool(name, args, correlation_id)
    # _execute_tool handles DISPATCHING_TOOL → WAITING_FOR_TOOL → GENERATING internally
    # After return, state is GENERATING — re-enter DISPATCHING_TOOL for next tc
    if len(tool_calls) > 1 and tc is not tool_calls[-1]:
        self._sm.transition(GeneratorAction.DISPATCH_TOOL)  # loop: GENERATING → DISPATCHING_TOOL
    tool_call_log.append({"tool": name, "args": args, "result": str(result)})
    messages.append({"role": "tool", "content": str(result), "name": name})
# State is GENERATING after last tool — ready for next ollama.chat() iteration

Tool schemas — add to config/generator.yaml

tools:
  - name: web_search
    description: >
      Search the web for current information, news, prices, or recent events.
      Use when the answer requires up-to-date facts not in your training data.
    parameters:
      type: object
      properties:
        query:
          type: string
          description: Concise search query (English preferred)
      required: [query]

  - name: web_fetch
    description: >
      Fetch and extract the full text content of a specific URL.
      Use after web_search when snippets are insufficient and you need
      the complete page content. Requires a known URL.
    parameters:
      type: object
      properties:
        url:
          type: string
          description: Full URL to fetch (must start with http:// or https://)
      required: [url]

run_local.py — start tool agents

def _start_web_search(model: str) -> None:
    from local.tools.web_search_tool import WebSearchTool
    WebSearchTool().run()

def _start_web_fetch() -> None:
    from local.tools.web_fetch_tool import WebFetchTool
    WebFetchTool().run()

# In main(), after generator thread:
ws_thread = threading.Thread(target=_start_web_search, daemon=True, name="web_search")
ws_thread.start()
wf_thread = threading.Thread(target=_start_web_fetch, daemon=True, name="web_fetch")
wf_thread.start()
time.sleep(0.2)  # let tool agents subscribe before generator accepts queries