Xcode 26.2 build and ToolSpec concurrency issues

[SpiraMira]

Hi - Firstly, this is a great module, many thanks in advance. I hope to leverage its magic in my projects and hopefully contribute.

Background:

I was building a clone of your chat-ui-swift and ran into some AnyLanguageModel issues I don’t see mentioned in this repo. I am posting this related issue here since that repo doesn’t have an open Issues section.

Adding the local HuggingChatKit failed consistently (?), directly adding AnyLanguageModel-main succeeded, but with the following error in ‘convertToolToMLXSpec’: Type 'Any' does not conform to the 'Sendable’ protocol (see below).

    private func convertToolToMLXSpec(_ tool: any Tool) -> ToolSpec {
        // Convert AnyLanguageModel's GenerationSchema to JSON-compatible dictionary
        let parametersDict: [String: Any]

...
...
        return [
            "type": "function",
            "function": [                      <---- Type 'Any' does not conform to the 'Sendable' protocol
                "name": tool.name,
                "description": tool.description,
                "parameters": parametersDict,
            ],
        ]

• Circumventing the Sendable issue below is easy enough with an “as! any Sendable” - but that’s pretty ugly. I have a better approach, but it involves snapshotting and transforming the dict to something totally Sendable across concurrency or module boundaries. (see below soon)

Thanks again, Patrice

Environment:
macOS 26.2
Xcode 26.2 17C52

[SpiraMira]

just to expand on the solutions to this. There are two options:

Option A: a type coercion to as! any Sendable. However, this forces a compile but doesn’t “solve” the issue the concurrency checker is trying to protect us from. Essentially, the compiler cannot guarantee that all parameters are Sendable.

”parameters”: parametersDict as! any Sendable”

OptionB: a slightly more involved approach snapshotting and transforming Tool ([String: Any]) to a safely Sendable structure

    enum SendableValue: Sendable {
        case string(String)
        case int(Int)
        case double(Double)
        case bool(Bool)
        case array([SendableValue])
        case object([String: SendableValue])
        case null
    }

    func transformToSendable(_ value: Any) -> SendableValue? {
        switch value {
        case let v as String: return .string(v)
        case let v as Int: return .int(v)
        case let v as Double: return .double(v)
        case let v as Bool: return .bool(v)
            
        case let v as [Any]:
            return .null
            let values = v.compactMap(transformToSendable)
            return .array(values)
        
        case let v as [String: Any]:
            let values = v.compactMapValues(transformToSendable)
            return .object(values)
            
        case is NSNull:
            return .null
            
        default:
            return nil
        }
    }

    private func convertToolToMLXSpec(_ tool: any Tool) -> ToolSpec {
        // function scope this "tighter" ToolSpec - obviates the need for type specifying like SendableValue.string("") in the returned struct
        typealias ToolSpec = [String: SendableValue]

        // Convert AnyLanguageModel's GenerationSchema to JSON-compatible dictionary
        let parametersDict: [String: Any]
        
        // any Sendable is not a concrete type and ToolSpec is declared as ToolSpec = [String: any Sendable]
        // convert "Any" to "SendableValue", so we can pass ToolSpec (with confirmed sendables) safely across concurrency boundaries
        func makeSendableToolSpec(tool: Tool) -> ToolSpec {
            let sendableParametersDict: [String: SendableValue] = parametersDict.compactMapValues(transformToSendable) // [String: Any] -> [String: SendableValue]
            
            return [
                "type": .string("function"),
                "function": .object([
                    "name": .string(tool.name),
                    "description": .string(tool.description),
                    "parameters": .object(sendableParametersDict),
                ])
            ]
        }

        do {
            let resolvedSchema = tool.parameters.withResolvedRoot() ?? tool.parameters
            let encoder = JSONEncoder()
            let data = try encoder.encode(resolvedSchema)
            if let json = try JSONSerialization.jsonObject(with: data) as? [String: Any] {
                parametersDict = json
            } else {
                parametersDict = ["type": "object", "properties": [:], "required": []]
            }
        } catch {
            parametersDict = ["type": "object", "properties": [:], "required": []]
        }

        return makeSendableToolSpec(tool: tool)
    }

[noorbhatia]

Perhaps something like this can be done as suggested in #71 by @XMLHexagram

private func convertToolToMLXSpec(_ tool: any Tool) -> ToolSpec {
        // Convert AnyLanguageModel's GenerationSchema to Sendable dictionary
        // using MLXLMCommon.JSONValue which is already Sendable
        let parametersValue: JSONValue
        do {
            let resolvedSchema = tool.parameters.withResolvedRoot() ?? tool.parameters
            let data = try JSONEncoder().encode(resolvedSchema)
            parametersValue = try JSONDecoder().decode(JSONValue.self, from: data)
        } catch {
            parametersValue = .object(["type": .string("object"), "properties": .object([:]), "required": .array([])])
        }

        return [
            "type": "function",
            "function": [
                "name": tool.name,
                "description": tool.description,
                "parameters": parametersValue,
            ] as [String: any Sendable],
        ]
    }

[SpiraMira]

@noorbhatia - yet another option. Yours is nice, compact, and leverages some existing MLXLMCommon magic I wasn’t aware of.