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.

[mattt]

Hi @SpiraMira. Sorry for the botched patch release and radio silence over the holidays. I just merged #72, which cherry-picks those changes in #71.

I just released 0.5.3 with these changes. I'm away from my primary work station, and can't run all of the local inference tests at the moment. But they pass CI, build, and seem to run alright, so I'm reasonably confident that we're stable now. Please give this a try when you have a chance, and let me know if you're still having problems 🙏