Swift AI SDK

The Swift AI SDK is a toolkit for building AI applications in Swift across Apple platforms and server-side Swift. It ports the AI SDK Core from the TypeScript version, providing a unified API for text generation, structured data, and tool calling.

Included Components

• SwiftAISDK (Core): The main API for generateText, streamText, and generateObject.
• Provider System: Integrations for 38+ providers (e.g., OpenAIProvider, AnthropicProvider, GoogleProvider).
• AISDKProvider: Foundation types and protocols like LanguageModelV3.
• AISDKProviderUtils: Utilities for HTTP, JSON, schema validation, and retries.
• AISDKZodAdapter: A Zod-like DSL for defining structured data schemas.

Not Included

Unlike the TypeScript SDK, this does not include web-specific UI libraries (like useChat or useCompletion) or React Server Components (RSC) utilities. For hybrid apps, use the Swift AI SDK on the server and the TypeScript AI SDK UI on the frontend.

The Google Provider implementation in Swift AI SDK provides parity with the Vercel AI SDK's Google implementation. It supports Gemini models, tool calling, embeddings, and multimodal inputs (images, video, files).

Key Capabilities

• Tool Calling: Tools are encoded as an array under functionDeclarations to ensure Gemini compatibility.
• Built-in Provider Tools: Supports specialized tools like google_search, url_context, code_execution, enterprise_web_search, file_search, vertex_rag_store, and google_maps.
• Multimodal Support: Handles images (including aspect-ratio configuration like 21:9), video (mapping n to sampleCount), and file URLs (Google Files/YouTube).
• Embeddings: Supports embedding requests with configurable outputDimensionality (accepts any numeric value).
• Grounding: Extracts grounding sources from web, retrievedContext (HTTP URLs, file URIs, fileSearchStore), and maps chunks.

Configuration & Requirements

• API Key: Requires the GOOGLE_GENERATIVE_AI_API_KEY environment variable. If missing, the SDK throws a LoadAPIKeyError at request-time.
• Vertex AI: Note that google-vertex progress is tracked separately; this provider focuses on the standard Google Generative AI implementation.

// Note: Actual initialization code depends on the specific SDK entry point,
// but ensure GOOGLE_GENERATIVE_AI_API_KEY is set in your environment.

A tool is an object that allows a Large Language Model (LLM) to perform discrete tasks or interact with the outside world (e.g., fetching weather or performing math). Tools are passed to generateText or streamText via the tools parameter.

A tool consists of three main components:

• description: An optional string that helps the LLM decide when to use the tool.
• inputSchema: A Codable type that defines the parameters the tool accepts. The SDK automatically derives the JSON Schema from this type.
• execute: An optional asynchronous function that receives the validated arguments and returns a result.

If a tool includes an execute function, it runs automatically when the LLM emits a tool call. The results are returned to the LLM as tool-result parts, enabling multi-step reasoning.

// Conceptual structure of a tool
let myTool = tool(
  description: "Description of what the tool does",
  inputSchema: MyCodableInput.self
) { input, _ in
  // Execution logic
  return MyResult()
}

Models like kimi-k2-thinking generate intermediate reasoning tokens. You can configure these via providerOptions using the moonshotai key.

Reasoning Configuration Options

thinking (object)

• type: 'enabled' | 'disabled'
• budgetTokens: number (minimum 1024)

reasoningHistory (string)

• 'disabled': Remove reasoning from history.
• 'interleaved': Include reasoning between tool calls within a single turn.
• 'preserved': Keep all reasoning in history.

import SwiftAISDK
import MoonshotAIProvider

let result = try await generateText(
  model: try moonshotai.chatModel(modelId: "kimi-k2-thinking"),
  providerOptions: [
    "moonshotai": [
      "thinking": [
        "type": "enabled",
        "budgetTokens": 2048
      ],
      "reasoningHistory": "interleaved"
    ]
  ],
  prompt: "How many \"r\"s are in the word \"strawberry\"?"
)

print(result.reasoningText ?? "")
print(result.text)

For reasoning models (like gpt-5), you can enable reasoning summaries via reasoningSummary in providerOptions.

Streaming: Reasoning summaries appear as events with type .reasoning(delta) in the stream.

Non-streaming: Reasoning summaries are available in the reasoning field of the response object.

// Streaming example
let result = try streamText(
  model: openai("gpt-5"),
  prompt: "Tell me about the Mission burrito debate in San Francisco.",
  providerOptions: [
    "openai": [
      "reasoningSummary": "detailed"
    ]
  ]
)

for try await part in result.fullStream {
  switch part {
  case .reasoning(let delta):
    print("Reasoning: \(delta)")
  case .textDelta(let delta):
    print(delta, terminator: "")
  default:
    break
  }
}

// Non-streaming example
let result = try await generateText(
  model: openai("gpt-5"),
  prompt: "...",
  providerOptions: ["openai": ["reasoningSummary": "auto"]]
)
print("Reasoning:", result.reasoning ?? "")