diff --git a/firebase-ai-ksp-processor/README.md b/firebase-ai-ksp-processor/README.md
new file mode 100644
index 00000000000..6460d9ff410
--- /dev/null
+++ b/firebase-ai-ksp-processor/README.md
@@ -0,0 +1,13 @@
+To build run `./gradlew :publishToMavenLocal`
+
+To integrate: add the following to your app's gradle file:
+
+```kotlin
+plugins {
+    id("com.google.devtools.ksp")
+}
+dependencies {
+    implementation("com.google.firebase:firebase-ai:<latest_version>")
+    ksp("com.google.firebase:firebase-ai-processor:1.0.0")
+}
+```
diff --git a/firebase-ai-ksp-processor/build.gradle.kts b/firebase-ai-ksp-processor/build.gradle.kts
new file mode 100644
index 00000000000..16df3455759
--- /dev/null
+++ b/firebase-ai-ksp-processor/build.gradle.kts
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+  kotlin("jvm")
+  id("java-library")
+  id("maven-publish")
+}
+
+dependencies {
+  testImplementation(kotlin("test"))
+  implementation(libs.symbol.processing.api)
+  implementation(libs.kotlinpoet.ksp)
+}
+
+tasks.test { useJUnitPlatform() }
+
+kotlin { jvmToolchain(21) }
+
+publishing {
+  publications {
+    create<MavenPublication>("mavenKotlin") {
+      from(components["kotlin"])
+      groupId = "com.google.firebase"
+      artifactId = "firebase-ai-processor"
+      version = "1.0.0"
+    }
+  }
+  repositories {
+    maven { url = uri("m2/") }
+    mavenLocal()
+  }
+}
diff --git a/firebase-ai-ksp-processor/gradle.properties b/firebase-ai-ksp-processor/gradle.properties
new file mode 100644
index 00000000000..7fc6f1ff272
--- /dev/null
+++ b/firebase-ai-ksp-processor/gradle.properties
@@ -0,0 +1 @@
+kotlin.code.style=official
diff --git a/firebase-ai-ksp-processor/src/main/kotlin/com/google/firebase/ai/ksp/SchemaSymbolProcessor.kt b/firebase-ai-ksp-processor/src/main/kotlin/com/google/firebase/ai/ksp/SchemaSymbolProcessor.kt
new file mode 100644
index 00000000000..99d9c6083dd
--- /dev/null
+++ b/firebase-ai-ksp-processor/src/main/kotlin/com/google/firebase/ai/ksp/SchemaSymbolProcessor.kt
@@ -0,0 +1,337 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.ai.ksp
+
+import com.google.devtools.ksp.KspExperimental
+import com.google.devtools.ksp.processing.CodeGenerator
+import com.google.devtools.ksp.processing.Dependencies
+import com.google.devtools.ksp.processing.KSPLogger
+import com.google.devtools.ksp.processing.Resolver
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.symbol.ClassKind
+import com.google.devtools.ksp.symbol.KSAnnotated
+import com.google.devtools.ksp.symbol.KSAnnotation
+import com.google.devtools.ksp.symbol.KSClassDeclaration
+import com.google.devtools.ksp.symbol.KSType
+import com.google.devtools.ksp.symbol.KSVisitorVoid
+import com.google.devtools.ksp.symbol.Modifier
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.CodeBlock
+import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.ParameterizedTypeName
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.TypeSpec
+import com.squareup.kotlinpoet.ksp.toClassName
+import com.squareup.kotlinpoet.ksp.toTypeName
+import com.squareup.kotlinpoet.ksp.writeTo
+import javax.annotation.processing.Generated
+
+public class SchemaSymbolProcessor(
+  private val codeGenerator: CodeGenerator,
+  private val logger: KSPLogger,
+) : SymbolProcessor {
+  override fun process(resolver: Resolver): List<KSAnnotated> {
+    resolver
+      .getSymbolsWithAnnotation("com.google.firebase.ai.annotations.Generable")
+      .filterIsInstance<KSClassDeclaration>()
+      .map { it to SchemaSymbolProcessorVisitor(it, resolver) }
+      .forEach { it.second.visitClassDeclaration(it.first, Unit) }
+
+    return emptyList()
+  }
+
+  private inner class SchemaSymbolProcessorVisitor(
+    private val klass: KSClassDeclaration,
+    private val resolver: Resolver,
+  ) : KSVisitorVoid() {
+    private val numberTypes = setOf("kotlin.Int", "kotlin.Long", "kotlin.Double", "kotlin.Float")
+    private val baseKdocRegex = Regex("^\\s*(.*?)((@\\w* .*)|\\z)", RegexOption.DOT_MATCHES_ALL)
+    private val propertyKdocRegex =
+      Regex("\\s*@property (\\w*) (.*?)(?=@\\w*|\\z)", RegexOption.DOT_MATCHES_ALL)
+
+    override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: Unit) {
+      val isDataClass = classDeclaration.modifiers.contains(Modifier.DATA)
+      if (!isDataClass) {
+        logger.error("${classDeclaration.qualifiedName} is not a data class")
+      }
+      val generatedSchemaFile = generateFileSpec(classDeclaration)
+      generatedSchemaFile.writeTo(
+        codeGenerator,
+        Dependencies(true, classDeclaration.containingFile!!),
+      )
+    }
+
+    fun generateFileSpec(classDeclaration: KSClassDeclaration): FileSpec {
+      return FileSpec.builder(
+          classDeclaration.packageName.asString(),
+          "${classDeclaration.simpleName.asString()}GeneratedSchema",
+        )
+        .addImport("com.google.firebase.ai.type", "JsonSchema")
+        .addType(
+          TypeSpec.classBuilder("${classDeclaration.simpleName.asString()}GeneratedSchema")
+            .addAnnotation(Generated::class)
+            .addType(
+              TypeSpec.companionObjectBuilder()
+                .addProperty(
+                  PropertySpec.builder(
+                      "SCHEMA",
+                      ClassName("com.google.firebase.ai.type", "JsonSchema")
+                        .parameterizedBy(
+                          ClassName(
+                            classDeclaration.packageName.asString(),
+                            classDeclaration.simpleName.asString()
+                          )
+                        ),
+                      KModifier.PUBLIC,
+                    )
+                    .mutable(false)
+                    .initializer(
+                      CodeBlock.builder()
+                        .add(
+                          generateCodeBlockForSchema(type = classDeclaration.asType(emptyList()))
+                        )
+                        .build()
+                    )
+                    .build()
+                )
+                .build()
+            )
+            .build()
+        )
+        .build()
+    }
+
+    @OptIn(KspExperimental::class)
+    fun generateCodeBlockForSchema(
+      name: String? = null,
+      description: String? = null,
+      type: KSType,
+      parentType: KSType? = null,
+      guideAnnotation: KSAnnotation? = null,
+    ): CodeBlock {
+      val parameterizedName = type.toTypeName() as? ParameterizedTypeName
+      val className = parameterizedName?.rawType ?: type.toClassName()
+      val kdocString = type.declaration.docString ?: ""
+      val baseKdoc = extractBaseKdoc(kdocString)
+      val propertyDocs = extractPropertyKdocs(kdocString)
+      val guideClassAnnotation =
+        type.annotations.firstOrNull() { it.shortName.getShortName() == "Guide" }
+      val description =
+        getDescriptionFromAnnotations(guideAnnotation, guideClassAnnotation, description, baseKdoc)
+      val minimum = getDoubleFromAnnotation(guideAnnotation, "minimum")
+      val maximum = getDoubleFromAnnotation(guideAnnotation, "maximum")
+      val minItems = getIntFromAnnotation(guideAnnotation, "minItems")
+      val maxItems = getIntFromAnnotation(guideAnnotation, "maxItems")
+      val format = getStringFromAnnotation(guideAnnotation, "format")
+      val pattern = getStringFromAnnotation(guideAnnotation, "pattern")
+      val builder = CodeBlock.builder()
+      when (className.canonicalName) {
+        "kotlin.Int" -> {
+          builder.addStatement("JsonSchema.integer(").indent()
+        }
+        "kotlin.Long" -> {
+          builder.addStatement("JsonSchema.long(").indent()
+        }
+        "kotlin.Boolean" -> {
+          builder.addStatement("JsonSchema.boolean(").indent()
+        }
+        "kotlin.Float" -> {
+          builder.addStatement("JsonSchema.float(").indent()
+        }
+        "kotlin.Double" -> {
+          builder.addStatement("JsonSchema.double(").indent()
+        }
+        "kotlin.String" -> {
+          builder.addStatement("JsonSchema.string(").indent()
+        }
+        "kotlin.collections.List" -> {
+          val listTypeParam = type.arguments.first().type!!.resolve()
+          val listParamCodeBlock =
+            generateCodeBlockForSchema(type = listTypeParam, parentType = type)
+          builder
+            .addStatement("JsonSchema.array(")
+            .indent()
+            .addStatement("items = ")
+            .add(listParamCodeBlock)
+            .addStatement(",")
+        }
+        else -> {
+          if ((type.declaration as? KSClassDeclaration)?.classKind == ClassKind.ENUM_CLASS) {
+            val enumValues =
+              (type.declaration as KSClassDeclaration)
+                .declarations
+                .filterIsInstance(KSClassDeclaration::class.java)
+                .map { it.simpleName.asString() }
+                .toList()
+            builder
+              .addStatement("JsonSchema.enumeration(")
+              .indent()
+              .addStatement("clazz = ${type.declaration.qualifiedName!!.asString()}::class.java,")
+              .addStatement("values = listOf(")
+              .indent()
+              .addStatement(enumValues.joinToString { "\"$it\"" })
+              .unindent()
+              .addStatement("),")
+          } else {
+            builder
+              .addStatement("JsonSchema.obj(")
+              .indent()
+              .addStatement("clazz = ${type.declaration.qualifiedName!!.asString()}::class.java,")
+              .addStatement("properties = mapOf(")
+              .indent()
+            val properties =
+              (type.declaration as KSClassDeclaration).getAllProperties().associate { property ->
+                val propertyName = property.simpleName.asString()
+                propertyName to
+                  generateCodeBlockForSchema(
+                    type = property.type.resolve(),
+                    parentType = type,
+                    description = propertyDocs[propertyName],
+                    name = propertyName,
+                    guideAnnotation =
+                      property.annotations.firstOrNull() { it.shortName.getShortName() == "Guide" },
+                  )
+              }
+            properties.entries.forEach {
+              builder
+                .addStatement("%S to ", it.key)
+                .indent()
+                .add(it.value)
+                .unindent()
+                .addStatement(", ")
+            }
+            builder.unindent().addStatement("),")
+          }
+        }
+      }
+      if (name != null) {
+        builder.addStatement("title = %S,", name)
+      }
+      if (description != null) {
+        builder.addStatement("description = %S,", description)
+      }
+      if ((minimum != null || maximum != null) && !numberTypes.contains(className.canonicalName)) {
+        logger.warn(
+          "${parentType?.toClassName()?.simpleName?.let { "$it." }}$name is not a number type, minimum and maximum are not valid parameters to specify in @Guide"
+        )
+      }
+      if (
+        (minItems != null || maxItems != null) &&
+          className.canonicalName != "kotlin.collections.List"
+      ) {
+        logger.warn(
+          "${parentType?.toClassName()?.simpleName?.let { "$it." }}$name is not a List type, minItems and maxItems are not valid parameters to specify in @Guide"
+        )
+      }
+      if ((format != null || pattern != null) && className.canonicalName != "kotlin.String") {
+        logger.warn(
+          "${parentType?.toClassName()?.simpleName?.let { "$it." }}$name is not a String type, format and pattern are not a valid parameter to specify in @Guide"
+        )
+      }
+      if (minimum != null) {
+        builder.addStatement("minimum = %L,", minimum)
+      }
+      if (maximum != null) {
+        builder.addStatement("maximum = %L,", maximum)
+      }
+      if (minItems != null) {
+        builder.addStatement("minItems = %L,", minItems)
+      }
+      if (maxItems != null) {
+        builder.addStatement("maxItems = %L,", maxItems)
+      }
+      if (format != null) {
+        builder.addStatement("format = %S,", format)
+      }
+      if (pattern != null) {
+        builder.addStatement("pattern = %S,", pattern)
+      }
+      builder.addStatement("nullable = %L)", className.isNullable).unindent()
+      return builder.build()
+    }
+
+    private fun getDescriptionFromAnnotations(
+      guideAnnotation: KSAnnotation?,
+      guideClassAnnotation: KSAnnotation?,
+      description: String?,
+      baseKdoc: String?,
+    ): String? {
+      val guidePropertyDescription = getStringFromAnnotation(guideAnnotation, "description")
+
+      val guideClassDescription = getStringFromAnnotation(guideClassAnnotation, "description")
+
+      return guidePropertyDescription ?: guideClassDescription ?: description ?: baseKdoc
+    }
+
+    private fun getDoubleFromAnnotation(
+      guideAnnotation: KSAnnotation?,
+      doubleName: String,
+    ): Double? {
+      val guidePropertyDoubleValue =
+        guideAnnotation
+          ?.arguments
+          ?.firstOrNull { it.name?.getShortName()?.equals(doubleName) == true }
+          ?.value as? Double
+      if (guidePropertyDoubleValue == null || guidePropertyDoubleValue == -1.0) {
+        return null
+      }
+      return guidePropertyDoubleValue
+    }
+
+    private fun getIntFromAnnotation(guideAnnotation: KSAnnotation?, intName: String): Int? {
+      val guidePropertyIntValue =
+        guideAnnotation
+          ?.arguments
+          ?.firstOrNull { it.name?.getShortName()?.equals(intName) == true }
+          ?.value as? Int
+      if (guidePropertyIntValue == null || guidePropertyIntValue == -1) {
+        return null
+      }
+      return guidePropertyIntValue
+    }
+
+    private fun getStringFromAnnotation(
+      guideAnnotation: KSAnnotation?,
+      stringName: String,
+    ): String? {
+      val guidePropertyStringValue =
+        guideAnnotation
+          ?.arguments
+          ?.firstOrNull { it.name?.getShortName()?.equals(stringName) == true }
+          ?.value as? String
+      if (guidePropertyStringValue.isNullOrEmpty()) {
+        return null
+      }
+      return guidePropertyStringValue
+    }
+
+    private fun extractBaseKdoc(kdoc: String): String? {
+      return baseKdocRegex.matchEntire(kdoc)?.groups?.get(1)?.value?.trim().let {
+        if (it.isNullOrEmpty()) null else it
+      }
+    }
+
+    private fun extractPropertyKdocs(kdoc: String): Map<String, String> {
+      return propertyKdocRegex
+        .findAll(kdoc)
+        .map { it.groups[1]!!.value to it.groups[2]!!.value.replace("\n", "").trim() }
+        .toMap()
+    }
+  }
+}
diff --git a/firebase-ai-ksp-processor/src/main/kotlin/com/google/firebase/ai/ksp/SchemaSymbolProcessorProvider.kt b/firebase-ai-ksp-processor/src/main/kotlin/com/google/firebase/ai/ksp/SchemaSymbolProcessorProvider.kt
new file mode 100644
index 00000000000..2c8015bc8a9
--- /dev/null
+++ b/firebase-ai-ksp-processor/src/main/kotlin/com/google/firebase/ai/ksp/SchemaSymbolProcessorProvider.kt
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.ai.ksp
+
+import com.google.devtools.ksp.processing.SymbolProcessor
+import com.google.devtools.ksp.processing.SymbolProcessorEnvironment
+import com.google.devtools.ksp.processing.SymbolProcessorProvider
+
+public class SchemaSymbolProcessorProvider : SymbolProcessorProvider {
+  override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor {
+    return SchemaSymbolProcessor(environment.codeGenerator, environment.logger)
+  }
+}
diff --git a/firebase-ai-ksp-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider b/firebase-ai-ksp-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider
new file mode 100644
index 00000000000..83d92f28c7e
--- /dev/null
+++ b/firebase-ai-ksp-processor/src/main/resources/META-INF/services/com.google.devtools.ksp.processing.SymbolProcessorProvider
@@ -0,0 +1 @@
+com.google.firebase.ai.ksp.SchemaSymbolProcessorProvider
\ No newline at end of file
diff --git a/firebase-ai/api.txt b/firebase-ai/api.txt
index 357fb1c2a8b..1e6cc6d6af5 100644
--- a/firebase-ai/api.txt
+++ b/firebase-ai/api.txt
@@ -98,6 +98,28 @@ package com.google.firebase.ai {
 
 }
 
+package com.google.firebase.ai.annotations {
+
+  @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.SOURCE) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface Generable {
+  }
+
+  @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.SOURCE) @kotlin.annotation.Target(allowedTargets={kotlin.annotation.AnnotationTarget.CLASS, kotlin.annotation.AnnotationTarget.PROPERTY}) public @interface Guide {
+    method public abstract String description() default "";
+    method public abstract String format() default "";
+    method public abstract int maxItems() default -1;
+    method public abstract double maximum() default -1.0;
+    method public abstract int minItems() default -1;
+    method public abstract double minimum() default -1.0;
+    property public abstract String description;
+    property public abstract String format;
+    property public abstract int maxItems;
+    property public abstract double maximum;
+    property public abstract int minItems;
+    property public abstract double minimum;
+  }
+
+}
+
 package com.google.firebase.ai.java {
 
   public abstract class ChatFutures {
diff --git a/firebase-ai/src/main/kotlin/com/google/firebase/ai/Chat.kt b/firebase-ai/src/main/kotlin/com/google/firebase/ai/Chat.kt
index 4ff2c3c8e82..b234498486b 100644
--- a/firebase-ai/src/main/kotlin/com/google/firebase/ai/Chat.kt
+++ b/firebase-ai/src/main/kotlin/com/google/firebase/ai/Chat.kt
@@ -18,9 +18,9 @@ package com.google.firebase.ai
 
 import android.graphics.Bitmap
 import com.google.firebase.ai.type.Content
+import com.google.firebase.ai.type.FunctionCallPart
+import com.google.firebase.ai.type.FunctionResponsePart
 import com.google.firebase.ai.type.GenerateContentResponse
-import com.google.firebase.ai.type.ImagePart
-import com.google.firebase.ai.type.InlineDataPart
 import com.google.firebase.ai.type.InvalidStateException
 import com.google.firebase.ai.type.Part
 import com.google.firebase.ai.type.TextPart
@@ -28,8 +28,9 @@ import com.google.firebase.ai.type.content
 import java.util.LinkedList
 import java.util.concurrent.Semaphore
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.FlowCollector
 import kotlinx.coroutines.flow.onCompletion
-import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.transform
 
 /**
  * Representation of a multi-turn interaction with a model.
@@ -52,25 +53,36 @@ public class Chat(
   private var lock = Semaphore(1)
 
   /**
-   * Sends a message using the provided [prompt]; automatically providing the existing [history] as
-   * context.
+   * Sends a message using the provided [inputPrompt]; automatically providing the existing
+   * [history] as context.
    *
    * If successful, the message and response will be added to the [history]. If unsuccessful,
    * [history] will remain unchanged.
    *
-   * @param prompt The input that, together with the history, will be given to the model as the
+   * @param inputPrompt The input that, together with the history, will be given to the model as the
    * prompt.
-   * @throws InvalidStateException if [prompt] is not coming from the 'user' role.
+   * @throws InvalidStateException if [inputPrompt] is not coming from the 'user' role.
    * @throws InvalidStateException if the [Chat] instance has an active request.
    */
-  public suspend fun sendMessage(prompt: Content): GenerateContentResponse {
-    prompt.assertComesFromUser()
+  public suspend fun sendMessage(inputPrompt: Content): GenerateContentResponse {
+    inputPrompt.assertComesFromUser()
     attemptLock()
+    var response: GenerateContentResponse
+    var prompt = inputPrompt
     try {
-      val fullPrompt = history + prompt
-      val response = model.generateContent(fullPrompt.first(), *fullPrompt.drop(1).toTypedArray())
-      history.add(prompt)
-      history.add(response.candidates.first().content)
+      while (true) {
+        response = model.generateContent(listOf(*history.toTypedArray(), prompt))
+        val responsePart = response.candidates.first().content.parts.first()
+
+        history.add(prompt)
+        history.add(response.candidates.first().content)
+        if (responsePart is FunctionCallPart) {
+          val output = model.executeFunction(responsePart)
+          prompt = Content("function", listOf(FunctionResponsePart(responsePart.name, output)))
+        } else {
+          break
+        }
+      }
       return response
     } finally {
       lock.release()
@@ -131,10 +143,8 @@ public class Chat(
 
     val fullPrompt = history + prompt
     val flow = model.generateContentStream(fullPrompt.first(), *fullPrompt.drop(1).toTypedArray())
-    val bitmaps = LinkedList<Bitmap>()
-    val inlineDataParts = LinkedList<InlineDataPart>()
-    val text = StringBuilder()
-    val parts = mutableListOf<Part>()
+    val tempHistory = LinkedList<Content>()
+    tempHistory.add(prompt)
 
     /**
      * TODO: revisit when images and inline data are returned. This will cause issues with how
@@ -142,28 +152,11 @@ public class Chat(
      * represented as image/text
      */
     return flow
-      .onEach {
-        for (part in it.candidates.first().content.parts) {
-          when (part) {
-            is TextPart -> text.append(part.text)
-            is ImagePart -> bitmaps.add(part.image)
-            is InlineDataPart -> inlineDataParts.add(part)
-          }
-          parts.add(part)
-        }
-      }
+      .transform { response -> automaticFunctionExecutingTransform(this, tempHistory, response) }
       .onCompletion {
         lock.release()
         if (it == null) {
-          val content =
-            content("model") {
-              setParts(
-                parts.filterNot { part -> part is TextPart && !part.hasContent() }.toMutableList()
-              )
-            }
-
-          history.add(prompt)
-          history.add(content)
+          history.addAll(tempHistory)
         }
       }
   }
@@ -206,6 +199,62 @@ public class Chat(
     return sendMessageStream(content)
   }
 
+  private suspend fun automaticFunctionExecutingTransform(
+    transformer: FlowCollector<GenerateContentResponse>,
+    tempHistory: LinkedList<Content>,
+    response: GenerateContentResponse
+  ) {
+    for (part in response.candidates.first().content.parts) {
+      when (part) {
+        is TextPart -> {
+          transformer.emit(response)
+          addTextToHistory(tempHistory, part)
+        }
+        is FunctionCallPart -> {
+          val functionCall =
+            response.candidates.first().content.parts.first { it is FunctionCallPart }
+              as FunctionCallPart
+          val output = model.executeFunction(functionCall)
+          val functionResponse =
+            Content("function", listOf(FunctionResponsePart(functionCall.name, output)))
+          tempHistory.add(response.candidates.first().content)
+          tempHistory.add(functionResponse)
+          model
+            .generateContentStream(listOf(*history.toTypedArray(), *tempHistory.toTypedArray()))
+            .collect { automaticFunctionExecutingTransform(transformer, tempHistory, it) }
+        }
+        else -> {
+          transformer.emit(response)
+          tempHistory.add(Content("model", listOf(part)))
+        }
+      }
+    }
+  }
+
+  private fun addTextToHistory(tempHistory: LinkedList<Content>, textPart: TextPart) {
+    val lastContent = tempHistory.lastOrNull()
+    if (lastContent?.role == "model" && lastContent.parts.any { it is TextPart }) {
+      tempHistory.removeLast()
+      val editedContent =
+        Content(
+          "model",
+          lastContent.parts.map {
+            when (it) {
+              is TextPart -> {
+                TextPart(it.text + textPart.text)
+              }
+              else -> {
+                it
+              }
+            }
+          }
+        )
+      tempHistory.add(editedContent)
+      return
+    }
+    tempHistory.add(Content("model", listOf(textPart)))
+  }
+
   private fun Content.assertComesFromUser() {
     if (role !in listOf("user", "function")) {
       throw InvalidStateException("Chat prompts should come from the 'user' or 'function' role.")
diff --git a/firebase-ai/src/main/kotlin/com/google/firebase/ai/GenerativeModel.kt b/firebase-ai/src/main/kotlin/com/google/firebase/ai/GenerativeModel.kt
index 45aa1e567e3..55f81b79d19 100644
--- a/firebase-ai/src/main/kotlin/com/google/firebase/ai/GenerativeModel.kt
+++ b/firebase-ai/src/main/kotlin/com/google/firebase/ai/GenerativeModel.kt
@@ -22,10 +22,12 @@ import com.google.firebase.ai.common.APIController
 import com.google.firebase.ai.common.AppCheckHeaderProvider
 import com.google.firebase.ai.common.CountTokensRequest
 import com.google.firebase.ai.common.GenerateContentRequest
+import com.google.firebase.ai.type.AutoFunctionDeclaration
 import com.google.firebase.ai.type.Content
 import com.google.firebase.ai.type.CountTokensResponse
 import com.google.firebase.ai.type.FinishReason
 import com.google.firebase.ai.type.FirebaseAIException
+import com.google.firebase.ai.type.FunctionCallPart
 import com.google.firebase.ai.type.GenerateContentResponse
 import com.google.firebase.ai.type.GenerationConfig
 import com.google.firebase.ai.type.GenerativeBackend
@@ -45,6 +47,11 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.map
 import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.InternalSerializationApi
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.serializerOrNull
 
 /**
  * Represents a multimodal model (like Gemini), capable of generating content based on various input
@@ -266,6 +273,43 @@ internal constructor(
     return countTokens(content { image(prompt) })
   }
 
+  @OptIn(InternalSerializationApi::class)
+  internal suspend fun executeFunction(call: FunctionCallPart): JsonObject {
+    if (tools == null) {
+      throw RuntimeException("No registered tools")
+    }
+    val tool = tools.flatMap { it.autoFunctionDeclarations?.filterNotNull() ?: emptyList() }
+    val declaration =
+      tool.firstOrNull() { it.name == call.name }
+        ?: throw RuntimeException("No registered function named ${call.name}")
+    return executeFunction<Any, Any>(
+      declaration as AutoFunctionDeclaration<Any, Any>,
+      call.args["param"].toString()
+    )
+  }
+
+  @OptIn(InternalSerializationApi::class)
+  internal suspend fun <I : Any, O : Any> executeFunction(
+    functionDeclaration: AutoFunctionDeclaration<I, O>,
+    parameter: String
+  ): JsonObject {
+    val inputDeserializer =
+      functionDeclaration.inputSchema.clazz.serializerOrNull()
+        ?: throw RuntimeException(
+          "Function input type ${functionDeclaration.inputSchema.clazz.qualifiedName} is not @Serializable"
+        )
+    val input = Json.decodeFromString(inputDeserializer, parameter)
+    val functionReference =
+      functionDeclaration.functionReference
+        ?: throw RuntimeException("Function reference for ${functionDeclaration.name} is missing")
+    val output = functionReference.invoke(input)
+    val outputSerializer = functionDeclaration.outputSchema?.clazz?.serializerOrNull()
+    if (outputSerializer != null) {
+      return Json.encodeToJsonElement(outputSerializer, output).jsonObject
+    }
+    return output as JsonObject
+  }
+
   @OptIn(ExperimentalSerializationApi::class)
   private fun constructRequest(vararg prompt: Content) =
     GenerateContentRequest(
diff --git a/firebase-ai/src/main/kotlin/com/google/firebase/ai/annotations/Generable.kt b/firebase-ai/src/main/kotlin/com/google/firebase/ai/annotations/Generable.kt
new file mode 100644
index 00000000000..b4a5e652ae5
--- /dev/null
+++ b/firebase-ai/src/main/kotlin/com/google/firebase/ai/annotations/Generable.kt
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.ai.annotations
+
+@Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.SOURCE)
+public annotation class Generable
diff --git a/firebase-ai/src/main/kotlin/com/google/firebase/ai/annotations/Guide.kt b/firebase-ai/src/main/kotlin/com/google/firebase/ai/annotations/Guide.kt
new file mode 100644
index 00000000000..c86237ecec9
--- /dev/null
+++ b/firebase-ai/src/main/kotlin/com/google/firebase/ai/annotations/Guide.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.ai.annotations
+
+@Target(AnnotationTarget.CLASS, AnnotationTarget.PROPERTY)
+@Retention(AnnotationRetention.SOURCE)
+public annotation class Guide(
+  public val description: String = "",
+  public val minimum: Double = -1.0,
+  public val maximum: Double = -1.0,
+  public val minItems: Int = -1,
+  public val maxItems: Int = -1,
+  public val format: String = "",
+  public val pattern: String = "",
+)
diff --git a/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/AutoFunctionDeclaration.kt b/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/AutoFunctionDeclaration.kt
new file mode 100644
index 00000000000..623f73d4ee2
--- /dev/null
+++ b/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/AutoFunctionDeclaration.kt
@@ -0,0 +1,55 @@
+package com.google.firebase.ai.type
+
+import kotlinx.serialization.json.JsonObject
+
+public class AutoFunctionDeclaration<I : Any, O : Any>
+internal constructor(
+  public val name: String,
+  public val description: String,
+  public val inputSchema: JsonSchema<I>,
+  public val outputSchema: JsonSchema<O>? = null,
+  public val functionReference: (suspend (I) -> O)? = null
+) {
+  public companion object {
+    public fun <I : Any, O : Any> create(
+      functionName: String,
+      description: String,
+      inputSchema: JsonSchema<I>,
+      outputSchema: JsonSchema<O>,
+      functionReference: ((I) -> O)? = null
+    ): AutoFunctionDeclaration<I, O> {
+      return AutoFunctionDeclaration<I, O>(
+        functionName,
+        description,
+        inputSchema,
+        outputSchema,
+        functionReference
+      )
+    }
+
+    public fun <I : Any> create(
+      functionName: String,
+      inputSchema: JsonSchema<I>,
+      description: String,
+      functionReference: ((I) -> JsonObject)? = null
+    ): AutoFunctionDeclaration<I, JsonObject> {
+      return AutoFunctionDeclaration<I, JsonObject>(
+        functionName,
+        description,
+        inputSchema,
+        null,
+        functionReference
+      )
+    }
+  }
+
+  internal fun toInternal(): FunctionDeclaration.Internal {
+    return FunctionDeclaration.Internal(
+      name,
+      description,
+      null,
+      JsonSchema.obj(mapOf("param" to inputSchema)).toInternalJson(),
+      outputSchema?.toInternalJson()
+    )
+  }
+}
diff --git a/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/FunctionDeclaration.kt b/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/FunctionDeclaration.kt
index 65b753efda7..7c7eb338ead 100644
--- a/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/FunctionDeclaration.kt
+++ b/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/FunctionDeclaration.kt
@@ -61,12 +61,14 @@ public class FunctionDeclaration(
   internal val schema: Schema =
     Schema.obj(properties = parameters, optionalProperties = optionalParameters, nullable = false)
 
-  internal fun toInternal() = Internal(name, description, schema.toInternalOpenApi())
+  internal fun toInternal() = Internal(name, description, schema.toInternalOpenApi(), null, null)
 
   @Serializable
   internal data class Internal(
     val name: String,
     val description: String,
-    val parameters: Schema.InternalOpenAPI
+    val parameters: Schema.InternalOpenAPI?,
+    val parametersJsonSchema: Schema.InternalJson?,
+    val responseJsonSchema: Schema.InternalJson?,
   )
 }
diff --git a/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/JsonSchema.kt b/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/JsonSchema.kt
new file mode 100644
index 00000000000..c59bb4a673b
--- /dev/null
+++ b/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/JsonSchema.kt
@@ -0,0 +1,492 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.ai.type
+
+import kotlin.reflect.KClass
+import kotlinx.serialization.json.JsonObject
+
+/**
+ * Definition of a data type.
+ *
+ * These types can be objects, but also primitives and arrays. Represents a select subset of an
+ * [JsonSchema object](https://json-schema.org/specification).
+ *
+ * **Note:** While optional, including a `description` field in your `JsonSchema` is strongly
+ * encouraged. The more information the model has about what it's expected to generate, the better
+ * the results.
+ */
+public class JsonSchema<T : Any>
+internal constructor(
+  public val type: String,
+  public val clazz: KClass<T>,
+  public val description: String? = null,
+  public val format: String? = null,
+  public val pattern: String? = null,
+  public val nullable: Boolean? = null,
+  public val enum: List<String>? = null,
+  public val properties: Map<String, JsonSchema<*>>? = null,
+  public val required: List<String>? = null,
+  public val items: JsonSchema<*>? = null,
+  public val title: String? = null,
+  public val minItems: Int? = null,
+  public val maxItems: Int? = null,
+  public val minimum: Double? = null,
+  public val maximum: Double? = null,
+  public val anyOf: List<JsonSchema<*>>? = null,
+) {
+
+  public companion object {
+    /**
+     * Returns a [JsonSchema] representing a boolean value.
+     *
+     * @param description An optional description of what the boolean should contain or represent.
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     */
+    @JvmStatic
+    @JvmOverloads
+    public fun boolean(
+      description: String? = null,
+      nullable: Boolean = false,
+      title: String? = null,
+    ): JsonSchema<Boolean> =
+      JsonSchema<Boolean>(
+        description = description,
+        nullable = nullable,
+        type = "BOOLEAN",
+        title = title,
+        clazz = Boolean::class
+      )
+
+    /**
+     * Returns a [JsonSchema] for a 32-bit signed integer number.
+     *
+     * **Important:** This [JsonSchema] provides a hint to the model that it should generate a
+     * 32-bit integer, but only guarantees that the value will be an integer. Therefore it's
+     * *possible* that decoding it as an `Int` variable (or `int` in Java) could overflow.
+     *
+     * @param description An optional description of what the integer should contain or represent.
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     */
+    @JvmStatic
+    @JvmName("numInt")
+    @JvmOverloads
+    public fun integer(
+      description: String? = null,
+      nullable: Boolean = false,
+      title: String? = null,
+      minimum: Double? = null,
+      maximum: Double? = null,
+    ): JsonSchema<Integer> =
+      JsonSchema(
+        description = description,
+        format = "int32",
+        nullable = nullable,
+        type = "INTEGER",
+        title = title,
+        minimum = minimum,
+        maximum = maximum,
+        clazz = Integer::class
+      )
+
+    /**
+     * Returns a [JsonSchema] for a 64-bit signed integer number.
+     *
+     * @param description An optional description of what the number should contain or represent.
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     */
+    @JvmStatic
+    @JvmName("numLong")
+    @JvmOverloads
+    public fun long(
+      description: String? = null,
+      nullable: Boolean = false,
+      title: String? = null,
+      minimum: Double? = null,
+      maximum: Double? = null,
+    ): JsonSchema<Long> =
+      JsonSchema(
+        description = description,
+        nullable = nullable,
+        type = "INTEGER",
+        title = title,
+        minimum = minimum,
+        maximum = maximum,
+        clazz = Long::class
+      )
+
+    /**
+     * Returns a [JsonSchema] for a double-precision floating-point number.
+     *
+     * @param description An optional description of what the number should contain or represent.
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     */
+    @JvmStatic
+    @JvmName("numDouble")
+    @JvmOverloads
+    public fun double(
+      description: String? = null,
+      nullable: Boolean = false,
+      title: String? = null,
+      minimum: Double? = null,
+      maximum: Double? = null,
+    ): JsonSchema<Double> =
+      JsonSchema(
+        description = description,
+        nullable = nullable,
+        type = "NUMBER",
+        title = title,
+        minimum = minimum,
+        maximum = maximum,
+        clazz = Double::class
+      )
+
+    /**
+     * Returns a [JsonSchema] for a single-precision floating-point number.
+     *
+     * **Important:** This [JsonSchema] provides a hint to the model that it should generate a
+     * single-precision floating-point number, but only guarantees that the value will be a number.
+     * Therefore it's *possible* that decoding it as a `Float` variable (or `float` in Java) could
+     * overflow.
+     *
+     * @param description An optional description of what the number should contain or represent.
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     */
+    @JvmStatic
+    @JvmName("numFloat")
+    @JvmOverloads
+    public fun float(
+      description: String? = null,
+      nullable: Boolean = false,
+      title: String? = null,
+      minimum: Double? = null,
+      maximum: Double? = null,
+    ): JsonSchema<Float> =
+      JsonSchema(
+        description = description,
+        nullable = nullable,
+        type = "NUMBER",
+        format = "float",
+        title = title,
+        minimum = minimum,
+        maximum = maximum,
+        clazz = Float::class
+      )
+
+    /**
+     * Returns a [JsonSchema] for a string.
+     *
+     * @param description An optional description of what the string should contain or represent.
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     * @param format An optional pattern that values need to adhere to.
+     */
+    @JvmStatic
+    @JvmName("str")
+    @JvmOverloads
+    public fun string(
+      description: String? = null,
+      nullable: Boolean = false,
+      format: StringFormat? = null,
+      title: String? = null,
+    ): JsonSchema<String> =
+      JsonSchema(
+        description = description,
+        format = format?.value,
+        nullable = nullable,
+        type = "STRING",
+        title = title,
+        clazz = String::class
+      )
+
+    /**
+     * Returns a [JsonSchema] for a complex data type.
+     *
+     * This schema instructs the model to produce data of type object, which has keys of type
+     * `String` and values of type [JsonSchema].
+     *
+     * **Example:** A `city` could be represented with the following object `JsonSchema`.
+     *
+     * ```
+     * JsonSchema.obj(mapOf(
+     *   "name"  to JsonSchema.string(),
+     *   "population" to JsonSchema.integer()
+     * ))
+     * ```
+     *
+     * @param properties The map of the object's property names to their [JsonSchema]s.
+     * @param optionalProperties The list of optional properties. They must correspond to the keys
+     * provided in the `properties` map. By default it's empty, signaling the model that all
+     * properties are to be included.
+     * @param description An optional description of what the object represents.
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     */
+    @JvmStatic
+    @JvmOverloads
+    public fun obj(
+      properties: Map<String, JsonSchema<*>>,
+      optionalProperties: List<String> = emptyList(),
+      description: String? = null,
+      nullable: Boolean = false,
+      title: String? = null,
+    ): JsonSchema<JsonObject> {
+      if (!properties.keys.containsAll(optionalProperties)) {
+        throw IllegalArgumentException(
+          "All optional properties must be present in properties. Missing: ${optionalProperties.minus(properties.keys)}"
+        )
+      }
+      return JsonSchema(
+        description = description,
+        nullable = nullable,
+        properties = properties,
+        required = properties.keys.minus(optionalProperties.toSet()).toList(),
+        type = "OBJECT",
+        title = title,
+        clazz = JsonObject::class
+      )
+    }
+
+    /**
+     * Returns a [JsonSchema] for a complex data type.
+     *
+     * This schema instructs the model to produce data of type object, which has keys of type
+     * `String` and values of type [JsonSchema].
+     *
+     * **Example:** A `city` could be represented with the following object `JsonSchema`.
+     *
+     * ```
+     * JsonSchema.obj(mapOf(
+     *     "name"  to JsonSchema.string(),
+     *     "population" to JsonSchema.integer()
+     *   ),
+     *   City::class
+     * )
+     * ```
+     *
+     * @param properties The map of the object's property names to their [JsonSchema]s.
+     * @param clazz the real class that this schema represents
+     * @param optionalProperties The list of optional properties. They must correspond to the keys
+     * provided in the `properties` map. By default it's empty, signaling the model that all
+     * properties are to be included.
+     * @param description An optional description of what the object represents.
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     */
+    @JvmStatic
+    @JvmOverloads
+    public fun <T : Any> obj(
+      properties: Map<String, JsonSchema<*>>,
+      clazz: KClass<T>,
+      optionalProperties: List<String> = emptyList(),
+      description: String? = null,
+      nullable: Boolean = false,
+      title: String? = null,
+    ): JsonSchema<T> {
+      if (!properties.keys.containsAll(optionalProperties)) {
+        throw IllegalArgumentException(
+          "All optional properties must be present in properties. Missing: ${optionalProperties.minus(properties.keys)}"
+        )
+      }
+      return JsonSchema(
+        description = description,
+        nullable = nullable,
+        properties = properties,
+        required = properties.keys.minus(optionalProperties.toSet()).toList(),
+        type = "OBJECT",
+        title = title,
+        clazz = clazz
+      )
+    }
+
+    /**
+     * Returns a [JsonSchema] for an array.
+     *
+     * @param items The [JsonSchema] of the elements stored in the array.
+     * @param description An optional description of what the array represents.
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     */
+    @JvmStatic
+    @JvmOverloads
+    public fun array(
+      items: JsonSchema<*>,
+      description: String? = null,
+      nullable: Boolean = false,
+      title: String? = null,
+      minItems: Int? = null,
+      maxItems: Int? = null,
+    ): JsonSchema<List<*>> =
+      JsonSchema(
+        description = description,
+        nullable = nullable,
+        items = items,
+        type = "ARRAY",
+        title = title,
+        minItems = minItems,
+        maxItems = maxItems,
+        clazz = List::class
+      )
+
+    /**
+     * Returns a [JsonSchema] for an enumeration.
+     *
+     * For example, the cardinal directions can be represented as:
+     * ```
+     * JsonSchema.enumeration(listOf("north", "east", "south", "west"), "Cardinal directions")
+     * ```
+     *
+     * @param values The list of valid values for this enumeration
+     * @param description The description of what the parameter should contain or represent
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     */
+    @JvmStatic
+    @JvmOverloads
+    public fun enumeration(
+      values: List<String>,
+      description: String? = null,
+      nullable: Boolean = false,
+      title: String? = null,
+    ): JsonSchema<String> =
+      JsonSchema(
+        description = description,
+        format = "enum",
+        nullable = nullable,
+        enum = values,
+        type = "STRING",
+        title = title,
+        clazz = String::class
+      )
+
+    /**
+     * Returns a [JsonSchema] for an enumeration.
+     *
+     * For example, the cardinal directions can be represented as:
+     * ```
+     * JsonSchema.enumeration(
+     *   listOf("north", "east", "south", "west"),
+     *   Direction::class,
+     *   "Cardinal directions"
+     * )
+     * ```
+     *
+     * @param values The list of valid values for this enumeration
+     * @param clazz the real class that this schema represents
+     * @param description The description of what the parameter should contain or represent
+     * @param nullable Indicates whether the value can be `null`. Defaults to `false`.
+     */
+    @JvmStatic
+    @JvmOverloads
+    public fun <T : Any> enumeration(
+      values: List<String>,
+      clazz: KClass<T>,
+      description: String? = null,
+      nullable: Boolean = false,
+      title: String? = null,
+    ): JsonSchema<T> =
+      JsonSchema(
+        description = description,
+        format = "enum",
+        nullable = nullable,
+        enum = values,
+        type = "STRING",
+        title = title,
+        clazz = clazz
+      )
+
+    /**
+     * Returns a [JsonSchema] representing a value that must conform to *any* (one of) the provided
+     * sub-schema.
+     *
+     * Example: A field that can hold either a simple userID or a more detailed user object.
+     *
+     * ```
+     * JsonSchema.anyOf( listOf( JsonSchema.integer(description = "User ID"), JsonSchema.obj( mapOf(
+     *     "userID" to JsonSchema.integer(description = "User ID"),
+     *     "username" to JsonSchema.string(description = "Username")
+     * )))
+     * ```
+     *
+     * @param schemas The list of valid schemas which could be here
+     */
+    @JvmStatic
+    public fun anyOf(schemas: List<JsonSchema<*>>): JsonSchema<String> =
+      JsonSchema(type = "ANYOF", anyOf = schemas, clazz = String::class)
+  }
+
+  internal fun toInternalJson(): Schema.InternalJson {
+    val outType =
+      if (type == "ANYOF" || (type == "STRING" && format == "enum")) {
+        null
+      } else {
+        type.lowercase()
+      }
+
+    val (outMinimum, outMaximum) =
+      if (outType == "integer" && format == "int32") {
+        (minimum ?: Integer.MIN_VALUE.toDouble()) to (maximum ?: Integer.MAX_VALUE.toDouble())
+      } else {
+        minimum to maximum
+      }
+
+    val outFormat =
+      if (
+        (outType == "integer" && format == "int32") ||
+          (outType == "number" && format == "float") ||
+          format == "enum"
+      ) {
+        null
+      } else {
+        format
+      }
+
+    if (nullable == true) {
+      return Schema.InternalJsonNullable(
+        outType?.let { listOf(it, "null") },
+        description,
+        outFormat,
+        pattern,
+        enum?.let {
+          buildList {
+            addAll(it)
+            add("null")
+          }
+        },
+        properties?.mapValues { it.value.toInternalJson() },
+        required,
+        items?.toInternalJson(),
+        title,
+        minItems,
+        maxItems,
+        outMinimum,
+        outMaximum,
+        anyOf?.map { it.toInternalJson() },
+      )
+    }
+    return Schema.InternalJsonNonNull(
+      outType,
+      description,
+      outFormat,
+      pattern,
+      enum,
+      properties?.mapValues { it.value.toInternalJson() },
+      required,
+      items?.toInternalJson(),
+      title,
+      minItems,
+      maxItems,
+      outMinimum,
+      outMaximum,
+      anyOf?.map { it.toInternalJson() },
+    )
+  }
+}
diff --git a/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/Schema.kt b/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/Schema.kt
index 1dfa4ddecb0..9f728adbbd4 100644
--- a/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/Schema.kt
+++ b/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/Schema.kt
@@ -378,6 +378,7 @@ internal constructor(
         outType?.let { listOf(it, "null") },
         description,
         outFormat,
+        null,
         enum?.let {
           buildList {
             addAll(it)
@@ -399,6 +400,7 @@ internal constructor(
       outType,
       description,
       outFormat,
+      null,
       enum,
       properties?.mapValues { it.value.toInternalJson() },
       required,
@@ -437,6 +439,7 @@ internal constructor(
     val type: String? = null,
     val description: String? = null,
     val format: String? = null,
+    val pattern: String? = null,
     val enum: List<String>? = null,
     val properties: Map<String, InternalJson>? = null,
     val required: List<String>? = null,
@@ -454,6 +457,7 @@ internal constructor(
     val type: List<String>? = null,
     val description: String? = null,
     val format: String? = null,
+    val pattern: String? = null,
     val enum: List<String>? = null,
     val properties: Map<String, InternalJson>? = null,
     val required: List<String>? = null,
diff --git a/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/Tool.kt b/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/Tool.kt
index 43a66a10d62..8b3e4329faf 100644
--- a/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/Tool.kt
+++ b/firebase-ai/src/main/kotlin/com/google/firebase/ai/type/Tool.kt
@@ -27,6 +27,7 @@ public class Tool
 @OptIn(PublicPreviewAPI::class)
 internal constructor(
   internal val functionDeclarations: List<FunctionDeclaration>?,
+  internal val autoFunctionDeclarations: List<AutoFunctionDeclaration<*, *>>?,
   internal val googleSearch: GoogleSearch?,
   internal val codeExecution: JsonObject?,
   @property:PublicPreviewAPI internal val urlContext: UrlContext?,
@@ -35,7 +36,10 @@ internal constructor(
   @OptIn(PublicPreviewAPI::class)
   internal fun toInternal() =
     Internal(
-      functionDeclarations?.map { it.toInternal() } ?: emptyList(),
+      buildList {
+        functionDeclarations?.let { addAll(it.map { it.toInternal() }) }
+        autoFunctionDeclarations?.let { addAll(it.map { it.toInternal() }) }
+      },
       googleSearch = this.googleSearch?.toInternal(),
       codeExecution = this.codeExecution,
       urlContext = this.urlContext?.toInternal()
@@ -53,7 +57,9 @@ internal constructor(
   public companion object {
 
     @OptIn(PublicPreviewAPI::class)
-    private val codeExecutionInstance by lazy { Tool(null, null, JsonObject(emptyMap()), null) }
+    private val codeExecutionInstance by lazy {
+      Tool(null, null, null, JsonObject(emptyMap()), null)
+    }
 
     /**
      * Creates a [Tool] instance that provides the model with access to the [functionDeclarations].
@@ -61,8 +67,12 @@ internal constructor(
      * @param functionDeclarations The list of functions that this tool allows the model access to.
      */
     @JvmStatic
-    public fun functionDeclarations(functionDeclarations: List<FunctionDeclaration>): Tool {
-      @OptIn(PublicPreviewAPI::class) return Tool(functionDeclarations, null, null, null)
+    public fun functionDeclarations(
+      functionDeclarations: List<FunctionDeclaration>? = null,
+      autoFunctionDeclarations: List<AutoFunctionDeclaration<*, *>>? = null
+    ): Tool {
+      @OptIn(PublicPreviewAPI::class)
+      return Tool(functionDeclarations, autoFunctionDeclarations, null, null, null)
     }
 
     /** Creates a [Tool] instance that allows the model to use code execution. */
@@ -82,7 +92,7 @@ internal constructor(
     @PublicPreviewAPI
     @JvmStatic
     public fun urlContext(urlContext: UrlContext = UrlContext()): Tool {
-      return Tool(null, null, null, urlContext)
+      return Tool(null, null, null, null, urlContext)
     }
 
     /**
@@ -103,7 +113,7 @@ internal constructor(
      */
     @JvmStatic
     public fun googleSearch(googleSearch: GoogleSearch = GoogleSearch()): Tool {
-      @OptIn(PublicPreviewAPI::class) return Tool(null, googleSearch, null, null)
+      @OptIn(PublicPreviewAPI::class) return Tool(null, null, googleSearch, null, null)
     }
   }
 }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 40e90c80350..652e42ffebb 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -45,6 +45,7 @@ jsonassert = "1.5.0"
 kotest = "5.9.0" # Do not use 5.9.1 because it reverts the fix for https://github.com/kotest/kotest/issues/3981
 kotestAssertionsCore = "5.8.1"
 kotlin = "2.0.21"
+kotlinpoetKsp = "2.2.0"
 ktorVersion = "3.0.3"
 legacySupportV4 = "1.0.0"
 lifecycleProcess = "2.3.1"
@@ -69,6 +70,7 @@ rxjava = "2.2.21"
 serialization = "1.7.3"
 slf4jNop = "2.0.17"
 spotless = "7.0.4"
+symbolProcessingApi = "2.2.10-2.0.2"
 testServices = "1.6.0"
 truth = "1.4.5"
 truthProtoExtension = "1.0"
@@ -142,6 +144,7 @@ kotlin-bom = { module = "org.jetbrains.kotlin:kotlin-bom", version.ref = "kotlin
 kotlin-coroutines-tasks = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-play-services", version.ref = "coroutines" }
 kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
 kotlin-stdlib-jdk8 = { module = "org.jetbrains.kotlin:kotlin-stdlib-jdk8", version.ref = "kotlin" }
+kotlinpoet-ksp = { module = "com.squareup:kotlinpoet-ksp", version.ref = "kotlinpoetKsp" }
 kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "coroutines" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
 kotlinx-coroutines-reactive = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-reactive", version.ref = "coroutines" }
@@ -203,6 +206,7 @@ rxandroid = { module = "io.reactivex.rxjava2:rxandroid", version.ref = "rxandroi
 rxjava = { module = "io.reactivex.rxjava2:rxjava", version.ref = "rxjava" }
 slf4j-nop = { module = "org.slf4j:slf4j-nop", version.ref = "slf4jNop" }
 spotless-plugin-gradle = { module = "com.diffplug.spotless:spotless-plugin-gradle", version.ref = "spotless" }
+symbol-processing-api = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "symbolProcessingApi" }
 truth = { module = "com.google.truth:truth", version.ref = "truth" }
 truth-liteproto-extension = { module = "com.google.truth.extensions:truth-liteproto-extension", version.ref = "truth" }
 truth-proto-extension = { module = "com.google.truth.extensions:truth-proto-extension", version.ref = "truthProtoExtension" }
diff --git a/subprojects.cfg b/subprojects.cfg
index f8505ecf8e7..a167e6eb58c 100644
--- a/subprojects.cfg
+++ b/subprojects.cfg
@@ -74,3 +74,5 @@ transport:transport-runtime-testing # sdk
 #firebase-storage:test-app
 #appcheck:firebase-appcheck:test-app
 #firebase-appdistribution:test-app
+
+firebase-ai-ksp-processor # buildtools