codesanitize

Within the earlier tutorials, we explored how Basis Fashions work in iOS 26 and how one can begin constructing AI-powered options utilizing this new framework. We additionally launched the @Generable macro, which makes it straightforward to transform generated responses into structured Swift varieties.

Now, in Half 3 of the Basis Fashions sequence, we’ll dive into one other highly effective functionality: Software Calling — a characteristic that lets the mannequin work together along with your app’s features to carry out duties, retrieve information, or set off actions based mostly on person enter.

The on-device language mannequin isn’t able to answering each sort of query, particularly people who require real-time information, like the present climate or the newest inventory costs. In different circumstances, you may want the mannequin to entry your app’s personal information to reply precisely. That’s the place Software Calling is available in that it permits the mannequin to delegate particular duties to your app’s features or exterior APIs.

On this tutorial, we’ll prolong the Ask Me Something app. Whereas the on-device mannequin can deal with normal queries, it doesn’t have entry to up-to-date details about trending motion pictures. To bridge that hole, we’ll use Software Calling to combine with the The Film Database (TMDB) API, enabling the mannequin to reply to movie-related questions utilizing reside information.

Utilizing TMDB APIs

In case you ask the Ask Me Something app about trending motion pictures, the on-device language mannequin received’t have the reply—it merely doesn’t have entry to that form of real-time data and should recommend checking different sources as a substitute. Let’s repair that utilizing Software Calling and the TMDB API. With this setup, each time a person asks a movie-related query, the mannequin received’t reply with “I don’t know.” As an alternative, it is going to robotically name the exterior API and return the related data instantly within the app.

Within the Xcode venture, create a MovieService file and insert the next code:

// Mannequin for a Film
struct Film: Codable, Identifiable {
    let id: Int
    let title: String
    let overview: String
    
    // Coding keys to match API response
    enum CodingKeys: String, CodingKey {
        case id
        case title
        case overview
    }
}

// Mannequin for the API response
struct TrendingMoviesResponse: Codable {
    let outcomes: [Movie]
}

// Service class to fetch trending motion pictures
class MovieService {
    // Base URL for TMDB API
    personal let baseURL = "https://api.themoviedb.org/3"
    
    personal let apiKey = ""
    
    // Operate to fetch trending motion pictures utilizing async/await
    func fetchTrendingMovies() async throws -> [Movie] {
        
        // Assemble the URL for trending motion pictures
        let urlString = "(baseURL)/trending/film/day?api_key=(apiKey)"
        guard let url = URL(string: urlString) else {
            throw URLError(.badURL)
        }
        
        // Carry out the community request
        let (information, response) = strive await URLSession.shared.information(from: url)
        
        // Verify for legitimate HTTP response
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).comprises(httpResponse.statusCode) else {
            throw URLError(.badServerResponse)
        }
        
        // Decode the JSON response
        let decoder = JSONDecoder()
        let trendingResponse = strive decoder.decode(TrendingMoviesResponse.self, from: information)
        return trendingResponse.outcomes
    }
}

Ensure you exchange the worth of apiKey with your personal TMDB API key. In case you haven’t signed up but, head over to themoviedb.org and register for a free account to get your API key.

The code above is pretty simple: it calls the net API to fetch trending motion pictures, then parses the response and decodes it into an array of Film objects.

Subsequent, we’ll use Software Calling to set off the code in MovieService each time the person asks about trending motion pictures. To get began, create a brand new file named GetTrendingMoviesTool.swift and add the next code:

import FoundationModels

struct GetTrendingMoviesTool: Software {
    let title = "getTrendingMovies"
    let description = "Get trending motion pictures and their data"
    
    let service = MovieService()

    @Generable
    struct Arguments {
        
    }
    
    func name(arguments: Arguments) async throws -> [String] {
        let motion pictures = strive await service.fetchTrendingMovies()
       
        let formattedMovies = motion pictures.map { film in
            "(film.title): (film.overview)"
        }
        
        return formattedMovies
    }
}

We outline a GetTrendingMovieTool struct that conforms to the Software protocol — that is the usual option to implement Software Calling within the Basis Fashions framework. The protocol requires you to specify a title and description for the instrument, together with an Arguments struct to symbolize any parameters the instrument would possibly want. On this case, we don’t require extra enter, so we outline an empty Arguments construction.

In case you needed to filter trending motion pictures by style, you could possibly outline Arguments like this:

@Generable
struct Arguments {
		@Information(description: "The style to fetch trending motion pictures")
		var style: String
}

When the instrument is triggered by the mannequin, the name methodology is robotically executed. Inside it, we name the fetchTrendingMovies() methodology from our service. After receiving the outcomes, we format them to show every film’s title and overview.

With the trending film instrument in place, integrating it into your app is easy. Merely open ContentView and replace the LanguageModelSession initialization as follows:

@State personal var session = LanguageModelSession(instruments: [GetTrendingMoviesTool()])

You may present customized instruments by passing them by way of the instruments parameter when initializing the language mannequin session. That’s it! The language mannequin will robotically invoke GetTrendingMoviesTool each time it detects a query associated to trending motion pictures.

Construct and run the app, then strive asking the identical query once more. This time, the mannequin will efficiently reply with trending film data by invoking the instrument.

Abstract

On this tutorial, we explored instrument calling, a strong addition to the Basis Fashions framework in iOS 26. In contrast to fundamental textual content technology, instrument calling permits the on-device language mannequin to work together along with your app’s features or entry exterior companies.

With instrument calling, you possibly can considerably prolong the mannequin’s capabilities. Whether or not it’s operating customized logic or fetching real-time information by way of APIs, the mannequin can now carry out context-aware duties past its built-in information.

I hope you’ve loved this tutorial sequence and really feel impressed to begin constructing smarter, AI-powered options utilizing the Basis Fashions framework.

I am working with SwiftData and attempting to share logic throughout a number of fashions utilizing protocols and protocol extensions.

I’ve created some frequent protocols like Queryable, StatusRepresentable, and Trackable, which my SwiftData fashions (e.g., Pet) conform to.

My mannequin seems to be like this:

@Mannequin
last class Pet {
    var id: UUID
    var title: String
    var statusRaw: String
    // ... different properties
}

And I outline these protocols:

protocol StatusRepresentable: AnyObject, PersistentModel {
    var statusRaw: String { get set }
}

extension StatusRepresentable {
    var standing: Standing {
        get { Standing(rawValue: statusRaw) ?? .energetic }
        set { statusRaw = newValue.rawValue }
    }

    func changeStatus(to newStatus: Standing) {
        if newStatus != standing {
            self.updateTimestamp(onChange: newStatus)
            self.statusRaw = newStatus.rawValue
        }
    }
}

And:

protocol Queryable: AnyObject, Identifiable, StatusRepresentable, PersistentModel {}

extension Queryable {
    static var activePredicate: Predicate {
        .withStatus(.energetic)
    }

    static func predicate(for id: UUID) -> Predicate the place Self.ID == UUID {
        .withId(id)
    }
}

Here is the problematic half:

I’m utilizing a generic predicate extension like this:

extension Predicate {
    static func withStatus(_ standing: Standing...) -> Predicate {
        let rawValues = standing.map { $0.rawValue }
        return #Predicate {
            rawValues.comprises($0.statusRaw)
        }
    }
}

Then in my SwiftUI View, I exploit it like so:

struct ComponentActiveList: View {
    @Question non-public var activePets: [Pet]

    init() {
        self._activePets = Question(
            filter: .activePredicate, // or .withStatus(.energetic)
            type: .title,
            order: .ahead
        )
    }

    var physique: some View {
        // ...
    }
}

The issue:

It compiles high quality, however crashes at runtime with this error (simplified):

keyPath: .statusRaw
Thread 1: EXC_BREAKPOINT (code=1, subcode=0x...)

Within the expanded macro, I can see this:

Basis.Predicate({
    PredicateExpressions.build_contains(
        PredicateExpressions.build_Arg(rawValues),
        PredicateExpressions.build_KeyPath(
            root: PredicateExpressions.build_Arg($0),
            keyPath: .statusRaw
        )
    )
})

It looks like the macro is having hassle resolving .statusRaw through protocol extension / dynamic lookup. I am guessing this has one thing to do with SwiftData + `#Predicate being unable to resolve protocol-constrained properties at runtime?

Earlier than introducing protocols like Queryable and StatusRepresentable, I had this working by duplicating the predicate logic for every mannequin individually – for instance:

extension Predicate {
    static func pets(with standing: Standing...) -> Predicate {
        let rawValues = standing.map { $0.rawValue }
        return #Predicate {
            rawValues.comprises($0.statusRaw)
        }
    }

    static func pet(with id: UUID) -> Predicate {
        #Predicate { $0.id == id }
    }
}

As a workaround, I’ve at the moment reverted all of the protocol code and am duplicating the predicate logic for every mannequin straight. However ideally, I’d wish to outline these in a single place through protocols or generics.

Drawback Description

When utilizing SwiftUI’s @Question with SwiftData fashions, I encountered confusion about reactivity triggering. In sure conditions, SwiftUI’s reactivity mechanism would not work as anticipated when the MessageData array adjustments.

Information Mannequin Definition

@Mannequin
last class MessageData: Equatable {
    @Attribute(.distinctive) public var identify: String
    public var etag: String?

    public static func == (lhs: MessageData, rhs: MessageData) -> Bool {
        // If each have etag, examine etags
        if let lhsEtag = lhs.etag, let rhsEtag = rhs.etag {
            return lhsEtag == rhsEtag
        }
        return false
    }
}

struct MessageForDisplay {
    public textual content: String
}

SwiftUI View Code

struct ChannelChatView: View {
    @Question non-public var messages: [MessageData]
    @State non-public var displayMessages: [MessageForDisplay]
    var physique: some View {
        MessagesView(messages: displayMessages)
        .onChange(of: messages, preliminary: true) { _, _ in
            prepareDisplayMessages(messages: messages)
        }
    }

    func prepareDisplayMessages(messages: [MessageData]) {
        // rework [MessageData] to [MessageForDisplay]
        displayMessages = messages.map { message in
            MessageForDisplay(textual content: message.textual content)
        }
    }
}

Set off Situations Comparability

Query
Why doesn’t onChange(of: messages) observe adjustments to properties of the objects returned by @Question? Is that this a limitation of SwiftData’s change monitoring, or am I lacking a unique sample for reacting to inside property adjustments?

Atmosphere

• Xcode 16.3
• iOS 18.1
• Swift 6.1
• SwiftData / SwiftUI

Any rationalization is appreciated!

I am encountering a wierd habits with the Marker element in react-native-maps when including markers dynamically.

After I faucet the map after including a marker to the editingMarkers state, the principalMarker (the inexperienced one representing the most recent tapped level) would not seem instantly.

But when I do any interplay afterward — zoom, pan, faucet once more, open the FAB menu, and many others. — then the marker instantly renders as anticipated.

It looks like the primary render is being ignored or delayed till a facet interplay forces a re-render.

Setup

• Expo SDK: ~53.0.20
• React Native: 0.79.5
• react-native-maps: 1.20.1

Hook & Handlers

const [markersOnEdit, setMarkersOnEdit] = useState([]);
const [principalMarker, setPrincipalMarker] = useState(null);

const handleMapPress = (occasion: MapPressEvent) => {
  setPrincipalMarker({
    latitude: occasion.nativeEvent.coordinate.latitude,
    longitude: occasion.nativeEvent.coordinate.longitude,
  });
};

const addNewMarker = () => {
  if (!principalMarker) return;

  const epsilon = 0.00001;
  const alreadyExists = markersOnEdit.some(
    (m) =>
      Math.abs(m.latitude - principalMarker.latitude) < epsilon &&
      Math.abs(m.longitude - principalMarker.longitude) < epsilon
  );

  if (alreadyExists) {
    // That is for forcing rendering
    setMarkersOnEdit((prev) => [...prev]);
    setPrincipalMarker({ ...principalMarker });
    return;
  }

  const newMarker: EditablePoint = {
    id: generateId(),
    latitude: principalMarker.latitude,
    longitude: principalMarker.longitude,
  };

  setMarkersOnEdit((prev) => [...prev, newMarker]);
  setPrincipalMarker(null);
};

MapView + Marker rendering

  
  {principalMarker !== null && (
    
  )}

  {markersOnEdit.map((level) => (
    
  ))}

Anticipated

As quickly as I set principalMarker, it ought to render immediately.

Precise

It would not render till one other interplay occurs.

Tried thus far

• Verified the state updates with console.log
• Confirmed principalMarker has right coordinates
• Pressured re-renders with unfold ({ ...marker }) or cloning arrays
• Tried calling setTimeout(() => setPrincipalMarker(...), 0)
• Tried mapRef.present?.forceUpdate();

Questions

• Is that this a bug with react-native-maps 1.20.1 or a quirk with React 19 / Expo SDK 53?
• Is there any identified workaround to power the marker to render on first map press?
• Anybody skilled comparable points or discovered a dependable repair?

Thanks prematurely 🙏