swift (v1.0): unregistered @call function is not routed to agent via callAgentFunction in bindings, checks, and action.functionCall #3689

Summary

In protocol v1.0, a FunctionCall ({"@call": "..."}) whose function has no local renderer implementation in the catalog should be routed to the agent via callAgentFunction (specification: specification/v1_0/docs/a2ui_protocol.md → § "Function Location Resolution & Fallback Routing", lines 1395–1426).

While A2UICore implements the programmatic RPC API (MessageProcessor.callAgentFunction and RPCHandler.callAgentFunction), DataContext and NodeResolver have no integration with RPCHandler:

1. When a property binding or validation check evaluates a function not implemented locally, DataContext.evaluateFunctionCall fails immediately with FunctionError.functionNotFound(callName) and resolves to .null (swift/core/Sources/A2UICore/State/DataContext.swift:152-158).
2. When a Button's action is configured as functionCall ({"action": {"functionCall": {"@call": "..."}}}), NodeResolver invokes evaluateDynamicValue(funcCallVal) (swift/core/Sources/A2UICore/Resolution/NodeResolver.swift:1490), triggering the same FunctionError.functionNotFound path in DataContext.
3. No CallAgentFunctionMessage is dispatched over the wire, and the agent never receives the RPC invocation.

In contrast, the Dart SDK (dart/a2ui_core) injects callAgentFunction into SurfaceModel and DataContext, correctly routing unregistered calls to the agent and awaiting AgentFunctionResponseMessage (tested in dart/a2ui_core/test/agent_function_fallback_test.dart).

Specification Reference

From specification/v1_0/docs/a2ui_protocol.md (§ "Function Location Resolution & Fallback Routing"):

When the renderer evaluates a FunctionCall (from an action handler, validation check, or dynamic value), it determines the execution target using implicit fallback routing:

1. Local Lookup: The renderer checks if a local renderer-side function with that name is registered in its local catalog/registry. If found, the renderer executes the function locally.
2. Fallback to Agent RPC: If the function is not registered in the local renderer catalog, the renderer assumes it is an agent-side function and dispatches a callAgentFunction message over the protocol.
3. Agent Error Handling: If the agent does not recognize the function name, the agent MUST return an agentFunctionResponse message containing an error payload. The renderer then handles the error state locally.

Affected Files

• swift/core/Sources/A2UICore/State/DataContext.swift (lines 130–168)
• swift/core/Sources/A2UICore/Resolution/NodeResolver.swift (lines 1456–1495)
• swift/core/Sources/A2UICore/Processing/MessageProcessor.swift (wiring to surface / resolution context)
• swift/core/Sources/A2UICore/Models/SurfaceViewModel.swift

Steps to Reproduce

1. In a v1.0 surface with the Basic Catalog, define a Button with a server-side action:

   {
     "id": "btn",
     "component": "Button",
     "child": "btn_text",
     "action": {
       "functionCall": {
         "@call": "createIssue",
         "args": {"title": "Sample Issue"}
       }
     }
   }

2. Set up MessageProcessor with an outbound listener to observe emitted renderer-to-agent messages.
3. Trigger the button's action.
4. Expected: A CallAgentFunctionMessage for createIssue is emitted to the outbound listener.
5. Actual: DataContext logs FunctionError.functionNotFound("createIssue"), returns .null, and no outbound message is emitted.

Suggested Fix

1. Follow the Dart pattern (dart/a2ui_core/lib/src/processing/processor.dart:665 and data_context.dart:724): pass a callAgentFunction delegate from MessageProcessor into SurfaceViewModel / DataContext.
2. In DataContext.evaluateFunctionCall, if the function is not found locally on a v1.0 surface and an RPC caller is available:
   • Dispatch callAgentFunction via the surface caller.
   • Return a placeholder/pending state that completes with the agentFunctionResponse value.
3. For action closures (ResolvedAction in NodeResolver), await the async RPC result when activated.
4. On error or timeout, invoke functionHandler?.handleFunctionError(...) with the structured RPC error.