From 1c26221b0b2033ad263c9222922b17456933eabb Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Mon, 26 Oct 2026 00:42:50 +0400 Subject: [PATCH 01/11] fix(adk): pass system messages as the agent instruction ADK replayed system messages as history turns, which sends a system role in the Gemini request contents and a [system] turn to Gemini Nano. Builds on #268. Co-Authored-By: Claude Opus 5.5 --- .../com/callstack/ai/adk/AdkAgentRunner.kt | 3 +- packages/adk/src/NativeAdkEngine.ts | 2 +- packages/adk/src/__tests__/ai-sdk.test.ts | 21 ++++++++++ packages/adk/src/ai-sdk.ts | 42 +++++++++---------- 4 files changed, 42 insertions(+), 26 deletions(-) diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt index 75d4ec2d..41a87d6e 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt @@ -425,8 +425,7 @@ class AdkAgentRunner( val message = messages.getMap(index) ?: continue val role = when (message.getString("role")) { "assistant" -> Role.MODEL - "system" -> Role.SYSTEM - "user", "tool" -> Role.USER + "user" -> Role.USER else -> throw IllegalArgumentException( "Unsupported message role: ${message.getString("role")}", ) diff --git a/packages/adk/src/NativeAdkEngine.ts b/packages/adk/src/NativeAdkEngine.ts index 9c5fffc5..4cb1b15b 100644 --- a/packages/adk/src/NativeAdkEngine.ts +++ b/packages/adk/src/NativeAdkEngine.ts @@ -1,7 +1,7 @@ import type { CodegenTypes, TurboModule } from 'react-native' import { Platform, TurboModuleRegistry } from 'react-native' -export type AdkMessageRole = 'assistant' | 'system' | 'user' +export type AdkMessageRole = 'assistant' | 'user' export type AdkMessagePart = | { type: 'text'; text: string } diff --git a/packages/adk/src/__tests__/ai-sdk.test.ts b/packages/adk/src/__tests__/ai-sdk.test.ts index 654eb6a6..4cb2316d 100644 --- a/packages/adk/src/__tests__/ai-sdk.test.ts +++ b/packages/adk/src/__tests__/ai-sdk.test.ts @@ -164,6 +164,27 @@ describe('model resolution', () => { }) describe('prompt conversion', () => { + test('moves system messages into the agent instruction', async () => { + const model = createAdkProvider({ + modelType: 'gemini', + instruction: 'Be brief.', + })() + await model.doGenerate( + createCallOptions({ + prompt: [ + { role: 'system', content: 'Answer in Polish.' }, + { role: 'user', content: [{ type: 'text', text: 'hello' }] }, + ], + }) + ) + + const [, messages, config] = lastGenerateCall() + expect(messages).toEqual([{ role: 'user', content: 'hello' }]) + expect(config).toMatchObject({ + instruction: 'Be brief.\n\nAnswer in Polish.', + }) + }) + test('resolves top-level file media types to a full mime type', async () => { await gemini.doGenerate( createCallOptions({ diff --git a/packages/adk/src/ai-sdk.ts b/packages/adk/src/ai-sdk.ts index e0ea49dc..8c8717ff 100644 --- a/packages/adk/src/ai-sdk.ts +++ b/packages/adk/src/ai-sdk.ts @@ -557,12 +557,10 @@ class AdkChatLanguageModel implements AdkLanguageModel { messages: LanguageModelV4Prompt, warnings: SharedV4Warning[] ): AdkMessage[] { - return messages.map((message): AdkMessage => { + // System messages become part of the agent instruction instead + return messages.flatMap((message): AdkMessage[] => { if (message.role === 'system') { - return { - role: 'system', - content: message.content, - } + return [] } if (message.role === 'user') { @@ -574,16 +572,10 @@ class AdkChatLanguageModel implements AdkLanguageModel { }) if (parts.length === 1 && parts[0]?.type === 'text') { - return { - role: 'user', - content: parts[0].text, - } + return [{ role: 'user', content: parts[0].text }] } - return { - role: 'user', - parts, - } + return [{ role: 'user', parts }] } if (message.role === 'assistant') { @@ -616,10 +608,7 @@ class AdkChatLanguageModel implements AdkLanguageModel { }) .join('\n') - return { - role: 'assistant', - content, - } + return [{ role: 'assistant', content }] } if (message.role === 'tool') { @@ -633,10 +622,7 @@ class AdkChatLanguageModel implements AdkLanguageModel { }) .join('\n') - return { - role: 'user', - content, - } + return [{ role: 'user', content }] } throw createAdkError( @@ -649,14 +635,24 @@ class AdkChatLanguageModel implements AdkLanguageModel { private prepareAgentConfig( options: LanguageModelV4CallOptions ): AdkAgentConfig { + // ADK only takes a system prompt as the agent instruction + const systemPrompts = options.prompt.flatMap((message) => + message.role === 'system' ? [message.content] : [] + ) // Gemini Nano has no response schema, so the schema goes in the instruction - if (!this.isNano || options.responseFormat?.type !== 'json') { + const jsonInstruction = + this.isNano && options.responseFormat?.type === 'json' + ? createNanoJsonInstruction(options.responseFormat.schema) + : undefined + + if (systemPrompts.length === 0 && !jsonInstruction) { return this.agentConfig } const instruction = [ this.agentConfig.instruction, - createNanoJsonInstruction(options.responseFormat.schema), + ...systemPrompts, + jsonInstruction, ] .filter(Boolean) .join('\n\n') From e72d5d839e6e859c82392773154a1cfb65100e82 Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Mon, 26 Oct 2026 00:49:22 +0400 Subject: [PATCH 02/11] fix(adk): report streamed tool calls without arguments The stream only ended a tool call once it had arguments, so a call to a tool without parameters had no tool-call part before its result. Co-Authored-By: Claude Opus 5.5 --- .../java/com/callstack/ai/adk/AdkStreamToolCalls.kt | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkStreamToolCalls.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkStreamToolCalls.kt index 705ad454..d5623ce5 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkStreamToolCalls.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkStreamToolCalls.kt @@ -60,8 +60,14 @@ class AdkStreamToolCallEmitter( } } - if (functionCall.args.isNotEmpty() && !state.completed) { - val input = AdkJson.encode(functionCall.args) + // A complete event carries the final arguments, which are empty for tools without parameters + if ((functionCall.args.isNotEmpty() || !event.partial) && state.started && !state.completed) { + val input = + if (functionCall.args.isEmpty() && state.inputBuilder.isNotEmpty()) { + state.inputBuilder.toString() + } else { + AdkJson.encode(functionCall.args) + } if (state.inputBuilder.isEmpty()) { emit( Arguments.createMap().apply { From 42334d312d7fba89be8719e76ac5b655cb145b6a Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Mon, 26 Oct 2026 00:49:28 +0400 Subject: [PATCH 03/11] fix(adk): route tool calls by run and fix tool, usage and seed handling - run tools with ADK's function call id, so execute sees the reported id - route tool calls by run id and tool name instead of a global registry - always send tool results as JSON, so strings stay strings natively - describe each Gemini Nano tool once in the instruction - drop the flat parameters list and fail on unsupported input schemas - sum token usage over every model call in a tool loop - warn that Gemini Nano ignores seed, and fix the docs table - track a run before starting it, so a run that ends at once is removed Co-Authored-By: Claude Opus 5.5 --- .../com/callstack/ai/adk/AdkAgentRunner.kt | 94 +++----- .../main/java/com/callstack/ai/adk/AdkJson.kt | 15 +- .../com/callstack/ai/adk/AdkToolBridge.kt | 52 ++--- .../java/com/callstack/ai/adk/AdkUsage.kt | 27 ++- .../callstack/ai/adk/NativeAdkEngineModule.kt | 50 +++-- .../ai/adk/ReactNativeFunctionTool.kt | 96 +++------ packages/adk/src/NativeAdkEngine.ts | 25 +-- packages/adk/src/__tests__/ai-sdk.test.ts | 74 ++++++- packages/adk/src/ai-sdk.ts | 201 ++++++------------ 9 files changed, 274 insertions(+), 360 deletions(-) diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt index 41a87d6e..91215ae8 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt @@ -16,7 +16,6 @@ import com.google.adk.kt.models.Model import com.google.adk.kt.runners.InMemoryRunner import com.google.adk.kt.sessions.InMemorySessionService import com.google.adk.kt.sessions.SessionKey -import com.google.adk.kt.tools.BaseTool import com.google.adk.kt.types.Blob import com.google.adk.kt.types.Content import com.google.adk.kt.types.GenerateContentConfig @@ -84,10 +83,10 @@ fun Event.textParts(thoughts: Boolean): String = class AdkAgentRunner( private val context: Context, private val onToolCall: ( + runId: String, toolCallId: String, - toolId: String, + toolName: String, arguments: String, - scope: ToolCallScope?, ) -> Unit, private val onDownloadProgress: ( phase: String, @@ -269,7 +268,7 @@ class AdkAgentRunner( toolCalls = toolCalls, toolResults = toolResults, finishReason = events.lastOrNull()?.finishReason?.name, - usage = AdkUsage.latestFromEvents(events), + usage = AdkUsage.fromEvents(events), ) } @@ -278,9 +277,9 @@ class AdkAgentRunner( config: ReadableMap, options: ReadableMap?, tools: ReadableArray?, - streamId: String, + runId: String, ): Flow { - return runAgent(messages, config, options, tools, stream = true, streamId = streamId) + return runAgent(messages, config, options, tools, stream = true, runId = runId) } private suspend fun runAgent( @@ -289,17 +288,11 @@ class AdkAgentRunner( options: ReadableMap?, tools: ReadableArray?, stream: Boolean, - streamId: String? = null, - runId: String? = null, + runId: String, ): Flow { val parsedMessages = parseMessages(messages) val agentConfig = parseAgentConfig(config) - val toolCallScope = when { - stream && streamId != null -> ToolCallScope(streamId = streamId) - !stream && runId != null -> ToolCallScope(runId = runId) - else -> null - } - val agentTools = parseTools(tools, toolCallScope, agentConfig.modelType) + val agentTools = parseTools(tools, runId) val model = createModel(agentConfig) val generateContentConfig = parseGenerationConfig(options) val instructionText = @@ -470,48 +463,32 @@ class AdkAgentRunner( context.contentResolver.openInputStream(Uri.parse(uri))?.use { it.readBytes() } ?: throw IllegalArgumentException("Cannot read file: $uri") - private fun parseTools( - tools: ReadableArray?, - toolCallScope: ToolCallScope?, - modelType: String, - ): List { + private fun parseTools(tools: ReadableArray?, runId: String): List { if (tools == null) return emptyList() - val injectPromptDescription = modelType == "genai-nano" - val parsed = mutableListOf() + val parsed = mutableListOf() for (index in 0 until tools.size()) { val tool = tools.getMap(index) ?: continue - val parametersArray = tool.getArray("parameters") - val parameters = mutableListOf() - - if (parametersArray != null) { - for (paramIndex in 0 until parametersArray.size()) { - val parameter = parametersArray.getMap(paramIndex) ?: continue - parameters.add( - ToolParameterSpec( - name = parameter.getString("name") ?: continue, - description = parameter.getString("description"), - type = parseParameterType(parameter.getString("type")), - required = parameter.hasKey("required") && parameter.getBoolean("required"), - ) - ) - } - } - + val name = tool.getString("name") ?: continue val parameterSchema = tool.getMap("inputSchema")?.let { schemaMap -> - runCatching { AdkSchema.fromReadableMap(schemaMap) }.getOrNull() + try { + AdkSchema.fromReadableMap(schemaMap) + } catch (error: Exception) { + throw AdkErrors.AdkException( + AdkErrors.INVALID_SCHEMA, + "Unsupported input schema for tool $name: ${error.message}", + error, + ) + } } parsed.add( ReactNativeFunctionTool( - toolId = tool.getString("id") ?: UUID.randomUUID().toString(), - name = tool.getString("name") ?: continue, + name = name, description = tool.getString("description") ?: "", parameterSchema = parameterSchema, - parameters = parameters, - injectPromptDescription = injectPromptDescription, - toolCallScope = toolCallScope, + runId = runId, onToolCall = onToolCall, ) ) @@ -520,24 +497,18 @@ class AdkAgentRunner( return parsed } + /** Gemini Nano has no native function calling, so its tools are described in the instruction. */ private fun buildInstruction( baseInstruction: String?, - tools: List, + tools: List, ): String? { if (tools.isEmpty()) { return baseInstruction } - val toolSummary = - tools.joinToString("\n") { tool -> - "- ${tool.name}: ${tool.description}" - } - val toolGuidance = - """ - You have access to the following tools. Use them when they help answer the user: - $toolSummary - """.trimIndent() + "You have access to the following tools. Use them when they help answer the user:\n" + + tools.joinToString("\n") { it.promptDescription() } return if (baseInstruction.isNullOrBlank()) { toolGuidance @@ -546,16 +517,6 @@ class AdkAgentRunner( } } - private fun parseParameterType(type: String?): com.google.adk.kt.types.Type { - return when (type) { - "number", "integer" -> com.google.adk.kt.types.Type.NUMBER - "boolean" -> com.google.adk.kt.types.Type.BOOLEAN - "array" -> com.google.adk.kt.types.Type.ARRAY - "object" -> com.google.adk.kt.types.Type.OBJECT - else -> com.google.adk.kt.types.Type.STRING - } - } - companion object { fun parseAgentConfig(config: ReadableMap): AgentConfig = parseAgentConfigStatic(config) @@ -593,8 +554,3 @@ data class ParsedMessage( val role: ContentRole, val content: Content, ) - -data class ToolCallScope( - val streamId: String? = null, - val runId: String? = null, -) diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkJson.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkJson.kt index da43e387..91cd71b0 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkJson.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkJson.kt @@ -2,24 +2,15 @@ package com.callstack.ai.adk import org.json.JSONArray import org.json.JSONObject +import org.json.JSONTokener object AdkJson { fun encode(value: Map): String { return mapToJsonObject(value).toString() } - fun decodeResult(value: String): Any? { - val trimmed = value.trim() - return when { - trimmed.startsWith("{") -> jsonObjectToMap(JSONObject(trimmed)) - trimmed.startsWith("[") -> jsonArrayToList(JSONArray(trimmed)) - trimmed == "true" -> true - trimmed == "false" -> false - trimmed == "null" -> null - trimmed.toDoubleOrNull() != null -> trimmed.toDouble() - else -> trimmed.removeSurrounding("\"") - } - } + /** Decodes a tool result, which JS always sends as JSON. */ + fun decodeResult(value: String): Any? = jsonValue(JSONTokener(value).nextValue()) private fun mapToJsonObject(value: Map): JSONObject { val json = JSONObject() diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkToolBridge.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkToolBridge.kt index 7b99145c..734f0c81 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkToolBridge.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkToolBridge.kt @@ -3,43 +3,37 @@ package com.callstack.ai.adk import kotlinx.coroutines.CompletableDeferred import java.util.concurrent.ConcurrentHashMap +/** Waits for tool results that JavaScript submits, grouped by run. */ object AdkToolBridge { - private val pendingResults = ConcurrentHashMap>() - private val streamToolCalls = ConcurrentHashMap>() + private val pendingResults = + ConcurrentHashMap>>() - suspend fun awaitResult(toolCallId: String): String { - val deferred = pendingResults.computeIfAbsent(toolCallId) { CompletableDeferred() } - val result = deferred.await() - pendingResults.remove(toolCallId, deferred) - return result - } - - fun registerToolCall(streamId: String, toolCallId: String) { - streamToolCalls.computeIfAbsent(streamId) { ConcurrentHashMap.newKeySet() }.add(toolCallId) + /** Registers the call before [request] asks JS to run it, then waits for the result. */ + suspend fun call(runId: String, toolCallId: String, request: () -> Unit): String { + val calls = pendingResults.computeIfAbsent(runId) { ConcurrentHashMap() } + val deferred = CompletableDeferred() + calls[toolCallId] = deferred + try { + request() + return deferred.await() + } finally { + calls.remove(toolCallId, deferred) + // Drop the run once it has no pending calls + pendingResults.computeIfPresent(runId) { _, runCalls -> runCalls.takeIf { it.isNotEmpty() } } + } } - fun submitResult(toolCallId: String, result: String) { - pendingResults.computeIfAbsent(toolCallId) { CompletableDeferred() }.complete(result) - streamToolCalls.values.forEach { toolCallIds -> toolCallIds.remove(toolCallId) } + fun submitResult(runId: String, toolCallId: String, result: String) { + pendingResults[runId]?.get(toolCallId)?.complete(result) } - fun cancelForStream(streamId: String) { - streamToolCalls.remove(streamId)?.forEach { toolCallId -> - pendingResults.remove(toolCallId)?.let { deferred -> - if (!deferred.isCompleted) { - deferred.complete("{\"error\":\"Tool call cancelled\"}") - } - } - } + fun cancel(runId: String) { + pendingResults.remove(runId)?.values?.forEach { it.complete(CANCELLED_RESULT) } } fun cancelAll() { - pendingResults.values.forEach { deferred -> - if (!deferred.isCompleted) { - deferred.complete("{\"error\":\"Tool call cancelled\"}") - } - } - pendingResults.clear() - streamToolCalls.clear() + pendingResults.keys.toList().forEach(::cancel) } + + private const val CANCELLED_RESULT = "{\"error\":\"Tool call cancelled\"}" } diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkUsage.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkUsage.kt index 48031929..4494e4c0 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkUsage.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkUsage.kt @@ -18,6 +18,29 @@ object AdkUsage { } } - fun latestFromEvents(events: List): UsageMetadata? = - events.mapNotNull { it.usageMetadata }.lastOrNull() + /** + * Usage of a whole run. A tool loop makes one model call per step, and each complete event + * carries the usage of its call, so the run's usage is their sum. + */ + fun fromEvents(events: List): UsageMetadata? = + events.filterNot { it.partial }.fold(null as UsageMetadata?) { total, event -> add(total, event) } + ?: events.mapNotNull { it.usageMetadata }.lastOrNull() + + /** Adds a complete event's usage to [total]. Partial events repeat their call's usage. */ + fun add(total: UsageMetadata?, event: Event): UsageMetadata? { + val usage = event.usageMetadata + if (event.partial || usage == null) return total + if (total == null) return usage + + return UsageMetadata( + promptTokenCount = sum(total.promptTokenCount, usage.promptTokenCount), + candidatesTokenCount = sum(total.candidatesTokenCount, usage.candidatesTokenCount), + totalTokenCount = sum(total.totalTokenCount, usage.totalTokenCount), + thoughtsTokenCount = sum(total.thoughtsTokenCount, usage.thoughtsTokenCount), + toolUsePromptTokenCount = sum(total.toolUsePromptTokenCount, usage.toolUsePromptTokenCount), + cachedContentTokenCount = sum(total.cachedContentTokenCount, usage.cachedContentTokenCount), + ) + } + + private fun sum(a: Int?, b: Int?): Int? = if (a == null && b == null) null else (a ?: 0) + (b ?: 0) } diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt index 416c031f..53a546de 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt @@ -8,6 +8,7 @@ import com.facebook.react.bridge.ReadableMap import com.google.adk.kt.events.Event import com.google.adk.kt.types.UsageMetadata import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.CoroutineStart import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Job import kotlinx.coroutines.SupervisorJob @@ -25,17 +26,15 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO) private val runner = AdkAgentRunner( context = reactContext, - onToolCall = { toolCallId, toolId, arguments, toolCallScope -> - toolCallScope?.streamId?.let { AdkToolBridge.registerToolCall(it, toolCallId) } - toolCallScope?.runId?.let { AdkToolBridge.registerToolCall(it, toolCallId) } - val args = Arguments.createMap().apply { - putString("toolCallId", toolCallId) - putString("toolId", toolId) - putString("arguments", arguments) - toolCallScope?.streamId?.let { putString("streamId", it) } - toolCallScope?.runId?.let { putString("runId", it) } - } - emitOnToolCall(args) + onToolCall = { runId, toolCallId, toolName, arguments -> + emitOnToolCall( + Arguments.createMap().apply { + putString("runId", runId) + putString("toolCallId", toolCallId) + putString("toolName", toolName) + putString("arguments", arguments) + }, + ) }, onDownloadProgress = { phase, bytesDownloaded, bytesToDownload -> emitOnNanoDownloadProgress( @@ -125,7 +124,8 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : tools: ReadableArray?, promise: Promise, ) { - val job = scope.launch { + // Started after it is tracked, so a run that ends at once is still removed + val job = scope.launch(start = CoroutineStart.LAZY) { try { val result = runner.generateText(messages, config, options, tools, runId) val response = Arguments.createMap().apply { @@ -168,10 +168,11 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : promise.rejectWithCode(error) } finally { activeRuns.remove(runId) - AdkToolBridge.cancelForStream(runId) + AdkToolBridge.cancel(runId) } } activeRuns[runId] = job + job.start() } override fun streamText( @@ -187,9 +188,11 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : return } - val job = scope.launch { + val job = scope.launch(start = CoroutineStart.LAZY) { try { - var latestUsage: UsageMetadata? = null + // Summed over complete events, with the latest partial usage as a fallback + var totalUsage: UsageMetadata? = null + var partialUsage: UsageMetadata? = null // Per-turn state. Gemini Nano emits ```tool_code blocks (as streamed text) instead // of native function calls, and the marker can be split across stream chunks. // @@ -214,7 +217,8 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : runner.streamText(messages, config, options, tools, streamId).collect { event -> if (!isActive) return@collect - event.usageMetadata?.let { latestUsage = it } + totalUsage = AdkUsage.add(totalUsage, event) + if (event.partial) event.usageMetadata?.let { partialUsage = it } toolCallEmitter.handleEvent(event) toolCallEmitter.handleResults(event) @@ -274,7 +278,7 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : emittedText = currentTurnText } - emitComplete(streamId, event, latestUsage) + emitComplete(streamId, event, totalUsage ?: partialUsage) } } } catch (error: Exception) { @@ -286,10 +290,12 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : emitOnStreamError(errorArgs) } finally { activeRuns.remove(streamId) + AdkToolBridge.cancel(streamId) } } activeRuns[streamId] = job + job.start() promise.resolve(null) } @@ -303,12 +309,12 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : ) } - private fun emitComplete(streamId: String, event: Event, latestUsage: UsageMetadata?) { + private fun emitComplete(streamId: String, event: Event, usage: UsageMetadata?) { emitOnStreamComplete( Arguments.createMap().apply { putString("streamId", streamId) event.finishReason?.name?.let { putString("finishReason", it) } - AdkUsage.toWritableMap(latestUsage ?: event.usageMetadata)?.let { + AdkUsage.toWritableMap(usage)?.let { putMap("usage", it) } }, @@ -317,12 +323,12 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : override fun cancelStream(streamId: String, promise: Promise) { activeRuns.remove(streamId)?.cancel() - AdkToolBridge.cancelForStream(streamId) + AdkToolBridge.cancel(streamId) promise.resolve(null) } - override fun submitToolResult(toolCallId: String, result: String) { - AdkToolBridge.submitResult(toolCallId, result) + override fun submitToolResult(runId: String, toolCallId: String, result: String) { + AdkToolBridge.submitResult(runId, toolCallId, result) } override fun invalidate() { diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt index 734c968f..fe9289b5 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt @@ -1,103 +1,63 @@ package com.callstack.ai.adk -import com.google.adk.kt.models.LlmRequest +import com.google.adk.kt.tools.BaseTool import com.google.adk.kt.tools.FunctionTool import com.google.adk.kt.tools.ToolContext -import com.google.adk.kt.types.Content import com.google.adk.kt.types.FunctionDeclaration -import com.google.adk.kt.types.Part import com.google.adk.kt.types.Schema import com.google.adk.kt.types.Type import java.util.UUID +/** An ADK tool whose `execute` runs in JavaScript. */ class ReactNativeFunctionTool( - private val toolId: String, name: String, description: String, private val parameterSchema: Schema?, - private val parameters: List, - private val injectPromptDescription: Boolean, - private val toolCallScope: ToolCallScope?, + private val runId: String, private val onToolCall: ( + runId: String, toolCallId: String, - toolId: String, + toolName: String, arguments: String, - scope: ToolCallScope?, ) -> Unit, ) : FunctionTool(name = name, description = description) { - override fun declaration(): FunctionDeclaration { - val schema = - parameterSchema - ?: Schema( - type = Type.OBJECT, - properties = - parameters.associate { parameter -> - parameter.name to - Schema( - type = parameter.type, - description = parameter.description, - ) - }, - required = parameters.filter { it.required }.map { it.name }.ifEmpty { null }, - ) - - return FunctionDeclaration( + override fun declaration(): FunctionDeclaration = + FunctionDeclaration( name = name, description = description, - parameters = schema, + parameters = parameterSchema ?: Schema(type = Type.OBJECT), ) - } - - override suspend fun processLlmRequest( - toolContext: ToolContext, - llmRequest: LlmRequest, - ): LlmRequest { - val requestWithTool = super.processLlmRequest(toolContext, llmRequest) - if (!injectPromptDescription) { - return requestWithTool - } - - val declaration = declaration() + /** Describes the tool for models without native function calling. */ + fun promptDescription(): String { + val parameters = declaration().parameters val parameterLines = - declaration.parameters?.properties?.entries?.joinToString("\n") { (paramName, paramSchema) -> + parameters?.properties?.entries?.joinToString("\n") { (paramName, paramSchema) -> val paramType = paramSchema.type?.name?.lowercase() ?: "string" val paramDescription = paramSchema.description?.let { " — $it" } ?: "" - val required = - declaration.parameters?.required?.contains(paramName) == true + val required = parameters.required?.contains(paramName) == true " - $paramName ($paramType, required=$required)$paramDescription" } ?: "" - val toolDescription = - buildString { - append("Tool: ${declaration.name}") - if (declaration.description.isNotBlank()) { - append(" — ${declaration.description}") - } - if (parameterLines.isNotBlank()) { - append("\n Parameters:\n$parameterLines") - } + return buildString { + append("- $name") + if (description.isNotBlank()) { + append(": $description") } - - return requestWithTool.appendInstructions( - Content(parts = listOf(Part(text = toolDescription))), - ) + if (parameterLines.isNotBlank()) { + append("\n Parameters:\n$parameterLines") + } + } } override suspend fun execute(context: ToolContext, args: Map): Any { - val toolCallId = UUID.randomUUID().toString() - val argumentsJson = AdkJson.encode(args) - onToolCall(toolCallId, toolId, argumentsJson, toolCallScope) - val result = AdkToolBridge.awaitResult(toolCallId) - return AdkJson.decodeResult(result) - ?: throw IllegalArgumentException("Failed to decode result in ReactNativeFunctionTool::execute") + // Use ADK's id so JS sees the same id as the reported tool call + val toolCallId = context.functionCallId ?: UUID.randomUUID().toString() + val result = AdkToolBridge.call(runId, toolCallId) { + onToolCall(runId, toolCallId, name, AdkJson.encode(args)) + } + // ADK wraps values that are not maps under `result` + return AdkJson.decodeResult(result) ?: mapOf(BaseTool.RESULT_KEY to null) } } - -data class ToolParameterSpec( - val name: String, - val description: String?, - val type: Type, - val required: Boolean, -) diff --git a/packages/adk/src/NativeAdkEngine.ts b/packages/adk/src/NativeAdkEngine.ts index 4cb1b15b..9d6c611b 100644 --- a/packages/adk/src/NativeAdkEngine.ts +++ b/packages/adk/src/NativeAdkEngine.ts @@ -34,19 +34,10 @@ export interface AdkAgentConfig { } } -export interface AdkToolParameter { - name: string - description?: string - type?: 'string' | 'number' | 'boolean' | 'object' | 'array' - required?: boolean -} - export interface AdkTool { - id: string name: string description: string inputSchema?: CodegenTypes.UnsafeObject - parameters?: AdkToolParameter[] } export interface AdkResponseFormat { @@ -138,11 +129,11 @@ export interface StreamToolCallEvent { } export interface ToolCallEvent { + /** The `generateText` or `streamText` run that called the tool */ + runId: string toolCallId: string - toolId: string + toolName: string arguments: string - streamId?: string - runId?: string } export interface NanoDownloadProgressEvent { @@ -183,7 +174,8 @@ export interface Spec extends TurboModule { /** Cancels a stream or a `generateText` run by its id */ cancelStream(streamId: string): Promise - submitToolResult(toolCallId: string, result: string): void + /** `result` is JSON */ + submitToolResult(runId: string, toolCallId: string, result: string): void onStreamUpdate: CodegenTypes.EventEmitter onStreamComplete: CodegenTypes.EventEmitter @@ -193,13 +185,6 @@ export interface Spec extends TurboModule { onNanoDownloadProgress: CodegenTypes.EventEmitter } -declare global { - var __ADK_TOOLS__: Record< - string, - (args: string) => unknown | Promise - > -} - const NativeAdkEngine: Spec | null = Platform.OS === 'android' ? TurboModuleRegistry.getEnforcing('AdkEngine') diff --git a/packages/adk/src/__tests__/ai-sdk.test.ts b/packages/adk/src/__tests__/ai-sdk.test.ts index 4cb2316d..0f4afbc9 100644 --- a/packages/adk/src/__tests__/ai-sdk.test.ts +++ b/packages/adk/src/__tests__/ai-sdk.test.ts @@ -23,6 +23,7 @@ const onStreamComplete = createEmitter() const onStreamError = createEmitter() const onStreamToolCall = createEmitter() const onNanoDownloadProgress = createEmitter() +const onToolCall = createEmitter() let generateTextResult: Record = { content: 'ok', @@ -49,6 +50,9 @@ const streamText = mock( ) const prepareNano = mock(async (_nano?: unknown) => {}) const cancelStream = mock(async (_id: string) => {}) +const submitToolResult = mock( + (_runId: string, _toolCallId: string, _result: string) => {} +) const getModelInfo = mock(async (_modelType: string, _nano?: unknown) => ({ availability: 'downloadable', })) @@ -64,7 +68,8 @@ mock.module('react-native', () => ({ getModelInfo, isNanoSupported: async () => true, isAvailable: async () => true, - onToolCall: () => ({ remove: () => {} }), + onToolCall, + submitToolResult, onStreamUpdate, onStreamToolCall, onStreamComplete, @@ -123,6 +128,7 @@ beforeEach(() => { streamText.mockClear() prepareNano.mockClear() cancelStream.mockClear() + submitToolResult.mockClear() generateTextResult = { content: 'ok', finishReason: 'STOP' } }) @@ -343,6 +349,68 @@ describe('tool choice', () => { }) }) +describe('tool execution', () => { + // Calls the tool from native code during the run, then waits for its result + async function callTool( + execute: (input: unknown, options: { toolCallId: string }) => unknown, + eventRunId = (runId: string) => runId + ) { + const model = createAdkProvider({ + modelType: 'gemini', + availableTools: { + getWeather: { inputSchema: weatherTool.inputSchema, execute }, + } as never, + })() + generateText.mockImplementationOnce(async (runId: string) => { + onToolCall.emit({ + runId: eventRunId(runId), + toolCallId: 'adk-call-1', + toolName: 'getWeather', + arguments: '{"city":"Oslo"}', + }) + await new Promise((resolve) => setTimeout(resolve, 0)) + return generateTextResult + }) + + await model.doGenerate(createCallOptions({ tools: [weatherTool] })) + return submitToolResult.mock.calls.at(-1) + } + + test('runs the tool with the ADK tool call id', async () => { + const execute = mock(async () => ({ sky: 'clear' })) + const [, toolCallId, result] = (await callTool(execute))! + + expect(execute.mock.calls[0]).toMatchObject([ + { city: 'Oslo' }, + { toolCallId: 'adk-call-1' }, + ]) + expect(toolCallId).toBe('adk-call-1') + expect(result).toBe('{"sky":"clear"}') + }) + + test('sends string results as JSON', async () => { + const [, , result] = (await callTool(async () => '42'))! + + expect(result).toBe('"42"') + }) + + test('sends tool errors back to the model', async () => { + const [, , result] = (await callTool(async () => { + throw new Error('offline') + }))! + + expect(result).toBe('{"error":"offline"}') + }) + + test('ignores tool calls from other runs', async () => { + const execute = mock(async () => 'ok') + await callTool(execute, () => 'other') + + expect(execute).not.toHaveBeenCalled() + expect(submitToolResult).not.toHaveBeenCalled() + }) +}) + describe('generation options', () => { test('maps reasoning levels to a thinking budget', async () => { await gemini.doGenerate(createCallOptions({ reasoning: 'high' })) @@ -397,12 +465,12 @@ describe('generation options', () => { test('warns about settings Gemini Nano ignores', async () => { const result = await nano.doGenerate( - createCallOptions({ topP: 0.5, stopSequences: ['END'] }) + createCallOptions({ topP: 0.5, seed: 1, stopSequences: ['END'] }) ) expect( result.warnings.map((warning) => 'feature' in warning && warning.feature) - ).toEqual(['topP', 'stopSequences']) + ).toEqual(['topP', 'seed', 'stopSequences']) }) }) diff --git a/packages/adk/src/ai-sdk.ts b/packages/adk/src/ai-sdk.ts index 8c8717ff..142b0010 100644 --- a/packages/adk/src/ai-sdk.ts +++ b/packages/adk/src/ai-sdk.ts @@ -31,7 +31,6 @@ import { type AdkModelType, type AdkNanoModelConfig, type AdkTool, - type AdkToolParameter, type AdkUsageMetadata, getNativeAdkEngine, type NanoDownloadProgressEvent, @@ -386,24 +385,6 @@ const convertFinishReason = ( } } -const schemaPropertyToAdkParameter = ( - name: string, - value: unknown, - required: boolean -): AdkToolParameter => { - const schema = value as { - type?: string - description?: string - } - - return { - name, - description: schema?.description, - type: (schema?.type as AdkToolParameter['type']) ?? 'string', - required, - } -} - const uint8ArrayToBase64 = (bytes: Uint8Array): string => { let binary = '' for (let index = 0; index < bytes.length; index++) { @@ -668,8 +649,10 @@ class AdkChatLanguageModel implements AdkLanguageModel { {}) as AdkProviderOptions if (this.isNano) { + // ADK's ML Kit model only passes on temperature, topK and maxOutputTokens const unsupported = { topP: options.topP, + seed: options.seed, stopSequences: options.stopSequences, presencePenalty: options.presencePenalty, frequencyPenalty: options.frequencyPenalty, @@ -707,8 +690,8 @@ class AdkChatLanguageModel implements AdkLanguageModel { } private prepareTools(tools: Tool[], warnings: SharedV4Warning[]) { - return tools - .filter((tool): tool is LanguageModelV4FunctionTool => { + const functionTools = tools.filter( + (tool): tool is LanguageModelV4FunctionTool => { if (tool.type === 'function') { return true } @@ -717,59 +700,46 @@ class AdkChatLanguageModel implements AdkLanguageModel { feature: `provider-defined tool ${tool.name}`, }) return false - }) - .map((tool) => { - const required = Array.isArray(tool.inputSchema.required) - ? tool.inputSchema.required - : [] - const properties = tool.inputSchema.properties ?? {} - - const parameters = Object.entries(properties).map(([name, value]) => - schemaPropertyToAdkParameter(name, value, required.includes(name)) - ) + } + ) - const schema = jsonSchema(tool.inputSchema) + for (const tool of functionTools) { + if (!this.tools[tool.name]?.execute) { + warnings.push({ + type: 'other', + message: `Tool "${tool.name}" has no executor. Pass it to createAdkProvider via availableTools so ADK can run it.`, + }) + } + } - if (!this.tools[tool.name]?.execute) { - warnings.push({ - type: 'other', - message: `Tool "${tool.name}" has no executor. Pass it to createAdkProvider via availableTools so ADK can run it.`, - }) - } + return functionTools.map( + (tool): AdkTool => ({ + name: tool.name, + description: tool.description ?? '', + inputSchema: tool.inputSchema, + }) + ) + } - return { - native: { - id: generateId(), - name: tool.name, - description: tool.description ?? '', - inputSchema: tool.inputSchema, - parameters, - } satisfies AdkTool, - execute: async (modelInput: unknown) => { - const execute = this.tools[tool.name]?.execute - if (!execute) { - return { - error: `Tool "${tool.name}" is not available in this app.`, - } - } + private async executeTool( + tool: LanguageModelV4FunctionTool, + event: ToolCallEvent + ) { + const execute = this.tools[tool.name]?.execute + if (!execute) { + return { error: `Tool "${tool.name}" is not available in this app.` } + } - const text = - typeof modelInput === 'string' - ? modelInput - : JSON.stringify(modelInput ?? {}) - const toolCallArguments = await parseJSON({ - text, - schema, - }) - const opts: ToolExecutionOptions = { - toolCallId: generateId(), - messages: [], - context: undefined, - } - return execute(toolCallArguments, opts) - }, - } - }) + const input = await parseJSON({ + text: event.arguments, + schema: jsonSchema(tool.inputSchema), + }) + const options: ToolExecutionOptions = { + toolCallId: event.toolCallId, + messages: [], + context: undefined, + } + return execute(input, options) } private prepareCall(options: LanguageModelV4CallOptions) { @@ -779,78 +749,46 @@ class AdkChatLanguageModel implements AdkLanguageModel { ) const messages = this.prepareMessages(options.prompt, warnings) const generationOptions = this.prepareGenerationOptions(options, warnings) - const preparedTools = this.prepareTools(tools, warnings) return { messages, generationOptions, - preparedTools, - nativeTools: preparedTools.map((tool) => tool.native), - ownedToolIds: new Set(preparedTools.map((tool) => tool.native.id)), + tools, + nativeTools: this.prepareTools(tools, warnings), agentConfig: this.prepareAgentConfig(options), warnings, } } - private registerTools( - preparedTools: ReturnType - ) { - globalThis.__ADK_TOOLS__ = globalThis.__ADK_TOOLS__ ?? {} - - for (const tool of preparedTools) { - globalThis.__ADK_TOOLS__[tool.native.id] = tool.execute - } - } - - private unregisterTools( - preparedTools: ReturnType - ) { - for (const tool of preparedTools) { - delete globalThis.__ADK_TOOLS__?.[tool.native.id] - } - } - - private createToolCallListener(scope: { - streamId?: string - runId?: string - ownedToolIds: Set - }) { + // Runs the tools that native code calls during `runId` + private listenForToolCalls(runId: string, tools: Tool[]) { const native = getNativeAdkEngine() return native.onToolCall(async (event: ToolCallEvent) => { - if (scope.streamId !== undefined && event.streamId !== scope.streamId) { - return - } - if (scope.runId !== undefined && event.runId !== scope.runId) { - return - } - if (!scope.ownedToolIds.has(event.toolId)) { - return - } - - const executor = globalThis.__ADK_TOOLS__?.[event.toolId] - if (!executor) { - native.submitToolResult( - event.toolCallId, - JSON.stringify({ error: `Tool not found: ${event.toolId}` }) - ) + if (event.runId !== runId) { return } + const tool = tools.find( + (candidate): candidate is LanguageModelV4FunctionTool => + candidate.type === 'function' && candidate.name === event.toolName + ) + let result: unknown try { - const result = await executor(event.arguments) - native.submitToolResult( - event.toolCallId, - typeof result === 'string' ? result : JSON.stringify(result ?? {}) - ) + result = tool + ? await this.executeTool(tool, event) + : { error: `Tool not found: ${event.toolName}` } } catch (error) { - native.submitToolResult( - event.toolCallId, - JSON.stringify({ - error: error instanceof Error ? error.message : String(error), - }) - ) + result = { + error: error instanceof Error ? error.message : String(error), + } } + // Always JSON, so native code can tell strings from other values + native.submitToolResult( + runId, + event.toolCallId, + JSON.stringify(result ?? null) + ) }) } @@ -858,9 +796,8 @@ class AdkChatLanguageModel implements AdkLanguageModel { const { messages, generationOptions, - preparedTools, + tools, nativeTools, - ownedToolIds, agentConfig, warnings, } = this.prepareCall(options) @@ -878,8 +815,7 @@ class AdkChatLanguageModel implements AdkLanguageModel { .catch((error) => console.warn('[adk] cancel failed:', error)) } - this.registerTools(preparedTools) - const toolListener = this.createToolCallListener({ runId, ownedToolIds }) + const toolListener = this.listenForToolCalls(runId, tools) abortSignal?.addEventListener('abort', onAbort, { once: true }) try { @@ -936,7 +872,6 @@ class AdkChatLanguageModel implements AdkLanguageModel { } finally { abortSignal?.removeEventListener('abort', onAbort) toolListener.remove() - this.unregisterTools(preparedTools) } } @@ -944,9 +879,8 @@ class AdkChatLanguageModel implements AdkLanguageModel { const { messages, generationOptions, - preparedTools, + tools, nativeTools, - ownedToolIds, agentConfig, warnings, } = this.prepareCall(options) @@ -965,11 +899,9 @@ class AdkChatLanguageModel implements AdkLanguageModel { throw getAbortReason(abortSignal) } - this.registerTools(preparedTools) - let listeners: { remove(): void }[] = [] let cleanedUp = false - const toolListener = this.createToolCallListener({ streamId, ownedToolIds }) + const toolListener = this.listenForToolCalls(streamId, tools) const toolNames = new Map() let onAbort = () => {} @@ -985,7 +917,6 @@ class AdkChatLanguageModel implements AdkLanguageModel { listeners = [] abortSignal?.removeEventListener('abort', onAbort) toolListener.remove() - this.unregisterTools(preparedTools) } const cancelNative = () => { From 5b98d8fbc2b0a2e7ac1154704615adb6c2c03b80 Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Mon, 26 Oct 2026 00:51:47 +0400 Subject: [PATCH 04/11] refactor(adk): hide gemini nano tool_code text in one place Kotlin held back tool_code markers and JS held back JSON fences. Both now live in a tested StreamTextFilter, and tool_code text is only hidden for Gemini Nano. Co-Authored-By: Claude Opus 5.5 --- .../callstack/ai/adk/NativeAdkEngineModule.kt | 69 ++------------ packages/adk/src/__tests__/ai-sdk.test.ts | 25 +++++ packages/adk/src/__tests__/streamText.test.ts | 56 +++++++++++ packages/adk/src/ai-sdk.ts | 41 ++------- packages/adk/src/streamText.ts | 92 +++++++++++++++++++ 5 files changed, 190 insertions(+), 93 deletions(-) create mode 100644 packages/adk/src/__tests__/streamText.test.ts create mode 100644 packages/adk/src/streamText.ts diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt index 53a546de..aca9c398 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt @@ -193,21 +193,11 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : // Summed over complete events, with the latest partial usage as a fallback var totalUsage: UsageMetadata? = null var partialUsage: UsageMetadata? = null - // Per-turn state. Gemini Nano emits ```tool_code blocks (as streamed text) instead - // of native function calls, and the marker can be split across stream chunks. - // - // ADK/GenaiPrompt may deliver text either cumulatively (each event repeats the full - // text) or incrementally (each event carries only the new delta). We can't rely on - // either, so we reconstruct the full turn text ourselves by appending the delta of - // each event, then run marker detection and hold-back on that reconstruction. - // - // currentTurnText: full reconstructed text of the current agent turn - // emittedText: the prefix of currentTurnText already sent to JS - // suppressCurrentTurn: true once we confirm this turn is a tool-code turn - // currentTurnReasoning / emittedReasoning: the same for thought parts + // ADK may deliver text cumulatively (each event repeats the turn so far) or as + // deltas, so the turn text is rebuilt here and only the new part is sent to JS. + // JS hides Gemini Nano tool_code blocks. Reasoning is tracked the same way. var currentTurnText = "" var emittedText = "" - var suppressCurrentTurn = false var currentTurnReasoning = "" var emittedReasoning = "" val toolCallEmitter = AdkStreamToolCallEmitter(streamId) { args -> @@ -236,48 +226,25 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : } val text = event.textParts(thoughts = false) - if (text.isNotEmpty()) { - // Reconstruct the full turn text. If the event repeats what we already have - // (cumulative mode) take it as-is; otherwise treat it as an incremental delta - // and append it. This keeps a split marker (e.g. "```tool_" + "code") intact. currentTurnText = if (text.startsWith(currentTurnText)) text else currentTurnText + text - - // Once the full tool-code marker appears, suppress the rest of this turn. - if (currentTurnText.contains(TOOL_CODE_MARKER)) { - suppressCurrentTurn = true - } } - // When a tool-calling turn ends, reset per-turn state so the next turn - // (the actual answer) starts with a clean slate and streams normally. if (!event.partial && event.functionCalls().isNotEmpty()) { + // A tool call ends the turn, and the next turn starts with new text currentTurnText = "" emittedText = "" - suppressCurrentTurn = false currentTurnReasoning = "" emittedReasoning = "" - } - - if (!suppressCurrentTurn && !(event.isFinalResponse && !event.partial)) { - // Hold back any trailing substring that could be the beginning of the marker, - // so we never emit a partial "```", "```tool", etc. that later completes. - val safeEnd = currentTurnText.length - pendingMarkerPrefixLength(currentTurnText) - if (safeEnd > emittedText.length) { - emitDelta(streamId, currentTurnText.substring(emittedText.length, safeEnd), "text") - emittedText = currentTurnText.substring(0, safeEnd) - } + } else if (currentTurnText.length > emittedText.length && + currentTurnText.startsWith(emittedText) + ) { + emitDelta(streamId, currentTurnText.substring(emittedText.length), "text") + emittedText = currentTurnText } if (event.isFinalResponse && !event.partial) { - // Flush any held-back text for a normal turn (e.g. a response legitimately - // ending in backticks that turned out not to be a tool-code marker). - if (!suppressCurrentTurn && currentTurnText.length > emittedText.length) { - emitDelta(streamId, currentTurnText.substring(emittedText.length), "text") - emittedText = currentTurnText - } - emitComplete(streamId, event, totalUsage ?: partialUsage) } } @@ -339,25 +306,7 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : super.invalidate() } - /** - * Returns the length of the trailing suffix of [text] that is a proper prefix of - * [TOOL_CODE_MARKER] (e.g. "`", "``", "```", "```tool"). This portion is held back - * from streaming because a subsequent token could complete the marker, at which point - * the whole turn is suppressed. If no suffix could begin the marker, returns 0. - */ - private fun pendingMarkerPrefixLength(text: String): Int { - val maxLen = minOf(text.length, TOOL_CODE_MARKER.length - 1) - for (len in maxLen downTo 1) { - val suffix = text.substring(text.length - len) - if (TOOL_CODE_MARKER.startsWith(suffix)) { - return len - } - } - return 0 - } - companion object { const val NAME = "AdkEngine" - private const val TOOL_CODE_MARKER = "```tool_code" } } diff --git a/packages/adk/src/__tests__/ai-sdk.test.ts b/packages/adk/src/__tests__/ai-sdk.test.ts index 0f4afbc9..4ec320d5 100644 --- a/packages/adk/src/__tests__/ai-sdk.test.ts +++ b/packages/adk/src/__tests__/ai-sdk.test.ts @@ -642,6 +642,31 @@ describe('doStream', () => { expect(text).toBe('{"a":1}') }) + test('hides Gemini Nano tool_code text and streams the next turn', async () => { + const parts = await runStream( + createCallOptions(), + (streamId) => { + for (const delta of ['Checking.\n``', '`tool_code\nf()\n```']) { + onStreamUpdate.emit({ streamId, delta }) + } + onStreamToolCall.emit({ + streamId, + phase: 'start', + toolCallId: '1', + toolName: 'f', + }) + onStreamUpdate.emit({ streamId, delta: 'Done.' }) + onStreamComplete.emit({ streamId }) + }, + nano + ) + + const text = parts + .flatMap((part) => (part.type === 'text-delta' ? [part.delta] : [])) + .join('') + expect(text).toBe('Checking.\nDone.') + }) + test('surfaces native stream errors with their code', async () => { const parts = await runStream(createCallOptions(), (streamId) => { onStreamError.emit({ diff --git a/packages/adk/src/__tests__/streamText.test.ts b/packages/adk/src/__tests__/streamText.test.ts new file mode 100644 index 00000000..6714bc81 --- /dev/null +++ b/packages/adk/src/__tests__/streamText.test.ts @@ -0,0 +1,56 @@ +import { describe, expect, test } from 'bun:test' + +import { StreamTextFilter } from '../streamText' + +function run( + deltas: string[], + options: { json?: boolean; toolCode?: boolean } = {} +) { + const filter = new StreamTextFilter({ + json: options.json ?? false, + toolCode: options.toolCode ?? false, + }) + const shown = deltas.map((delta) => filter.push(delta)) + return { shown, text: shown.join('') + filter.flush() } +} + +describe('StreamTextFilter', () => { + test('passes plain text through', () => { + expect(run(['Hel', 'lo']).shown).toEqual(['Hel', 'lo']) + }) + + test('hides a tool_code block split across deltas', () => { + const { shown, text } = run( + ['Let me check.\n``', '`tool_', 'code\ngetWeather()\n```'], + { toolCode: true } + ) + + expect(shown).toEqual(['Let me check.\n', '', '']) + expect(text).toBe('Let me check.\n') + }) + + test('shows held back backticks that are not a tool_code block', () => { + const { shown, text } = run(['Use ``', 'x`` here'], { toolCode: true }) + + expect(shown).toEqual(['Use ', '``x`` here']) + expect(text).toBe('Use ``x`` here') + }) + + test('starts a new turn after a tool call', () => { + const filter = new StreamTextFilter({ json: false, toolCode: true }) + filter.push('```tool_code\nf()\n```') + filter.endTurn() + + expect(filter.push('Done.')).toBe('Done.') + }) + + test('leaves tool_code text alone for other models', () => { + expect(run(['```tool_code\nf()\n```']).text).toBe('```tool_code\nf()\n```') + }) + + test('strips JSON code fences', () => { + expect( + run(['``', '`json\n{"a"', ':1}', '\n`', '``'], { json: true }).text + ).toBe('{"a":1}') + }) +}) diff --git a/packages/adk/src/ai-sdk.ts b/packages/adk/src/ai-sdk.ts index 142b0010..431f305c 100644 --- a/packages/adk/src/ai-sdk.ts +++ b/packages/adk/src/ai-sdk.ts @@ -37,6 +37,7 @@ import { type StreamToolCallEvent, type ToolCallEvent, } from './NativeAdkEngine' +import { StreamTextFilter, stripJsonFences } from './streamText' const DEFAULT_NANO_MODEL = 'gemini-nano' const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash' @@ -440,11 +441,6 @@ const getAbortReason = (signal: AbortSignal) => { const stringifyToolOutput = (value: unknown) => typeof value === 'string' ? value : JSON.stringify(value ?? null) -// Gemini Nano often wraps JSON in a Markdown code fence -const jsonFencePrefix = /^\s*```(?:json)?\s*\n?/ -const stripJsonFences = (text: string) => - text.replace(jsonFencePrefix, '').replace(/\s*```\s*$/, '') - const parseToolResult = (output: string): NonNullable => { try { return (JSON.parse(output) as JSONValue) ?? {} @@ -931,9 +927,10 @@ class AdkChatLanguageModel implements AdkLanguageModel { let textOpen = false let reasoningId: string | undefined let reasoningCount = 0 - // JSON mode keeps the full text so code fences can be stripped - let rawText = '' - let emittedText = '' + const textFilter = new StreamTextFilter({ + json: isJson, + toolCode: this.isNano, + }) const addListener = (listener: { remove(): void }) => { listeners.push(listener) @@ -958,21 +955,6 @@ class AdkChatLanguageModel implements AdkLanguageModel { controller.enqueue({ type: 'text-delta', id: textId, delta }) } - const emitJsonText = (final: boolean) => { - const stripped = final - ? stripJsonFences(rawText) - : // Hold back trailing backticks that could start a closing fence - rawText.replace(jsonFencePrefix, '').replace(/\s*`{1,3}$/, '') - // Only emit once the opening fence can no longer change the prefix - if (!final && /^\s*`{0,3}(j(s(o(n)?)?)?)?$/.test(rawText)) { - return - } - if (stripped.startsWith(emittedText)) { - emitText(stripped.slice(emittedText.length)) - emittedText = stripped - } - } - controller.enqueue({ type: 'stream-start', warnings }) onAbort = () => { @@ -1001,13 +983,7 @@ class AdkChatLanguageModel implements AdkLanguageModel { return } - if (isJson) { - rawText += data.delta - emitJsonText(false) - return - } - - emitText(data.delta) + emitText(textFilter.push(data.delta)) }) ) @@ -1019,6 +995,7 @@ class AdkChatLanguageModel implements AdkLanguageModel { if (data.phase === 'start' && data.toolName) { closeReasoning() + textFilter.endTurn() toolNames.set(data.toolCallId, data.toolName) controller.enqueue({ type: 'tool-input-start', @@ -1070,9 +1047,7 @@ class AdkChatLanguageModel implements AdkLanguageModel { if (data.streamId !== streamId) { return } - if (isJson) { - emitJsonText(true) - } + emitText(textFilter.flush()) closeReasoning() if (textOpen) { controller.enqueue({ type: 'text-end', id: textId }) diff --git a/packages/adk/src/streamText.ts b/packages/adk/src/streamText.ts new file mode 100644 index 00000000..1dc20fcf --- /dev/null +++ b/packages/adk/src/streamText.ts @@ -0,0 +1,92 @@ +// Gemini Nano writes tool calls as text, which ADK turns into function calls +const toolCodeMarker = '```tool_code' + +// Gemini Nano often wraps JSON in a Markdown code fence +const jsonFencePrefix = /^\s*```(?:json)?\s*\n?/ +// Text that could still grow into the opening fence +const partialJsonFence = /^\s*`{0,3}(j(s(o(n)?)?)?)?$/ + +export const stripJsonFences = (text: string) => + text.replace(jsonFencePrefix, '').replace(/\s*```\s*$/, '') + +// Length of the end of `text` that could be the start of `marker` +function pendingPrefixLength(text: string, marker: string) { + for ( + let length = Math.min(text.length, marker.length - 1); + length > 0; + length-- + ) { + if (marker.startsWith(text.slice(-length))) { + return length + } + } + return 0 +} + +/** + * Filters streamed model text. It hides Gemini Nano `tool_code` blocks and, in + * JSON mode, Markdown code fences, holding back text until it cannot become one. + */ +export class StreamTextFilter { + private turnText = '' + private emitted = '' + + constructor(private readonly options: { json: boolean; toolCode: boolean }) {} + + /** Adds a text delta and returns the text that is now safe to show */ + push(delta: string) { + this.turnText += delta + return this.take(false) + } + + /** Returns the rest of the text at the end of the stream */ + flush() { + return this.take(true) + } + + /** A tool call ended the model turn, so the next turn starts empty */ + endTurn() { + this.turnText = '' + this.emitted = '' + } + + private take(final: boolean) { + const visible = this.visibleText(final) + if (visible === undefined || !visible.startsWith(this.emitted)) { + return '' + } + const delta = visible.slice(this.emitted.length) + this.emitted = visible + return delta + } + + private visibleText(final: boolean): string | undefined { + let text = this.turnText + const markerIndex = this.options.toolCode + ? text.indexOf(toolCodeMarker) + : -1 + if (markerIndex !== -1) { + text = text.slice(0, markerIndex) + } + + if (this.options.json) { + if (final) { + return stripJsonFences(text) + } + if (partialJsonFence.test(text)) { + return undefined + } + // Hold back trailing backticks that could start a closing fence + text = text.replace(jsonFencePrefix, '').replace(/\s*`{1,3}$/, '') + } + + // Hold back the end of the text while it could still become the marker + if (this.options.toolCode && markerIndex === -1 && !final) { + text = text.slice( + 0, + text.length - pendingPrefixLength(text, toolCodeMarker) + ) + } + return text + } +} From cc352109f9ee5c0899364ce6cb9a02079992996e Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Mon, 26 Oct 2026 00:52:47 +0400 Subject: [PATCH 05/11] refactor(adk): drop duplicate native defaults and unused error code - Kotlin no longer repeats the agent and model defaults that JS sends - remove TOOL_CALL_ERROR, which native code never reports - build the unsupported platform error with createAdkError Co-Authored-By: Claude Opus 5.5 --- .../com/callstack/ai/adk/AdkAgentRunner.kt | 39 +++++++++---------- packages/adk/src/NativeAdkEngine.ts | 13 ++++--- packages/adk/src/errors.ts | 1 - 3 files changed, 25 insertions(+), 28 deletions(-) diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt index 91215ae8..ae390e70 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt @@ -354,9 +354,6 @@ class AdkAgentRunner( } } - private fun parseAgentConfig(config: ReadableMap): AgentConfig = - parseAgentConfigStatic(config) - private fun parseGenerationConfig(options: ReadableMap?): GenerateContentConfig? { if (options == null) return null @@ -517,23 +514,23 @@ class AdkAgentRunner( } } - companion object { - fun parseAgentConfig(config: ReadableMap): AgentConfig = parseAgentConfigStatic(config) - - private fun parseAgentConfigStatic(config: ReadableMap): AgentConfig { - val model = config.getMap("model") - ?: throw IllegalArgumentException("Agent config requires a model") - - return AgentConfig( - name = config.getString("name") ?: "react_native_adk_agent", - description = config.getString("description") ?: "", - instruction = config.getString("instruction"), - modelType = model.getString("type") ?: "genai-nano", - modelName = model.getString("name") ?: "gemini-nano", - apiKey = model.getString("apiKey"), - nano = NanoConfig.from(model.getMap("nano")), - ) - } + // JS always sends the name and model, with defaults applied + private fun parseAgentConfig(config: ReadableMap): AgentConfig { + fun ReadableMap.require(key: String) = + getString(key) ?: throw IllegalArgumentException("Agent config requires $key") + + val model = config.getMap("model") + ?: throw IllegalArgumentException("Agent config requires a model") + + return AgentConfig( + name = config.require("name"), + description = config.getString("description") ?: "", + instruction = config.getString("instruction"), + modelType = model.require("type"), + modelName = model.require("name"), + apiKey = model.getString("apiKey"), + nano = NanoConfig.from(model.getMap("nano")), + ) } } @@ -547,7 +544,7 @@ data class AgentConfig( val nano: NanoConfig, ) -/** ADK content role — one of [Role.USER], [Role.MODEL], or [Role.SYSTEM]. */ +/** ADK content role, [Role.USER] or [Role.MODEL]. */ private typealias ContentRole = String data class ParsedMessage( diff --git a/packages/adk/src/NativeAdkEngine.ts b/packages/adk/src/NativeAdkEngine.ts index 9d6c611b..fa8e5f47 100644 --- a/packages/adk/src/NativeAdkEngine.ts +++ b/packages/adk/src/NativeAdkEngine.ts @@ -1,6 +1,8 @@ import type { CodegenTypes, TurboModule } from 'react-native' import { Platform, TurboModuleRegistry } from 'react-native' +import { AdkErrorCodes, createAdkError } from './errors' + export type AdkMessageRole = 'assistant' | 'user' export type AdkMessagePart = @@ -172,7 +174,7 @@ export interface Spec extends TurboModule { tools?: AdkTool[] ): Promise - /** Cancels a stream or a `generateText` run by its id */ + /** Cancels a `streamText` or `generateText` run by its id */ cancelStream(streamId: string): Promise /** `result` is JSON */ submitToolResult(runId: string, toolCallId: string, result: string): void @@ -194,11 +196,10 @@ export default NativeAdkEngine export function getNativeAdkEngine(): Spec { if (!NativeAdkEngine) { - const error = new Error( - '@react-native-ai/adk is only available on Android. See https://developer.android.com/ai/adk' - ) as Error & { code: string } - error.code = 'UNSUPPORTED_PLATFORM' - throw error + throw createAdkError( + '@react-native-ai/adk is only available on Android. See https://developer.android.com/ai/adk', + AdkErrorCodes.UnsupportedPlatform + ) } return NativeAdkEngine } diff --git a/packages/adk/src/errors.ts b/packages/adk/src/errors.ts index 7b76f30d..89fd2e65 100644 --- a/packages/adk/src/errors.ts +++ b/packages/adk/src/errors.ts @@ -10,7 +10,6 @@ export const AdkErrorCodes = { GenerationError: 'GENERATION_ERROR', InvalidMessage: 'INVALID_MESSAGE', InvalidSchema: 'INVALID_SCHEMA', - ToolCallError: 'TOOL_CALL_ERROR', ContextWindowExceeded: 'CONTEXT_WINDOW_EXCEEDED', RateLimited: 'RATE_LIMITED', BackgroundUseBlocked: 'BACKGROUND_USE_BLOCKED', From 67c80325b0ca0a9e25218efa05ff6b5f7ad48a97 Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Mon, 26 Oct 2026 00:56:29 +0400 Subject: [PATCH 06/11] refactor(adk): align model, availability and prepare apis with apple - take the model id as a model option, like apple; modelType and modelName still work but are deprecated - getModelInfo takes a model and reports model and supportsTokenCounting - derive isAvailable from getModelInfo and deprecate isNanoSupported, removing the two native availability methods - report download progress from model.prepare({ onProgress }) and deprecate provider.prepareNano - default cloud Gemini to gemini-3.8-flash, since 2.5 models are limited to existing users Co-Authored-By: Claude Opus 5.5 --- .../com/callstack/ai/adk/AdkAgentRunner.kt | 18 -- .../callstack/ai/adk/NativeAdkEngineModule.kt | 24 -- packages/adk/src/NativeAdkEngine.ts | 5 - packages/adk/src/__tests__/ai-sdk.test.ts | 54 ++++- packages/adk/src/ai-sdk.ts | 214 ++++++++++-------- 5 files changed, 163 insertions(+), 152 deletions(-) diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt index ae390e70..91589ab8 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt @@ -117,13 +117,6 @@ class AdkAgentRunner( ) } - private suspend fun nanoStatus(config: NanoConfig): Int = - try { - nanoClient(config).checkStatus() - } catch (_: Exception) { - FeatureStatus.UNAVAILABLE - } - /** Downloads Gemini Nano when needed, reporting progress, then warms it up. */ suspend fun prepareNano(config: NanoConfig) { nanoPrepareMutex.withLock { @@ -178,17 +171,6 @@ class AdkAgentRunner( return nanoModels.getValue(config) } - /** Whether this device supports Gemini Nano at all. Does not download the model. */ - suspend fun isNanoSupported(config: NanoConfig): Boolean = - nanoStatus(config) != FeatureStatus.UNAVAILABLE - - /** Whether Gemini Nano is downloaded or can be downloaded now. */ - suspend fun isNanoAvailable(config: NanoConfig): Boolean = - when (nanoStatus(config)) { - FeatureStatus.DOWNLOADABLE, FeatureStatus.AVAILABLE -> true - else -> false - } - suspend fun getModelInfo(modelType: String, config: NanoConfig): AdkModelInfo { if (modelType != "genai-nano") { return AdkModelInfo(availability = "available") diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt index aca9c398..715a36e4 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt @@ -54,30 +54,6 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : reject(AdkErrors.codeFor(error), error.message ?: "Unknown ADK error", error) } - override fun isAvailable(modelType: String, nano: ReadableMap?, promise: Promise) { - scope.launch { - try { - val available = when (modelType) { - "genai-nano" -> runner.isNanoAvailable(NanoConfig.from(nano)) - else -> true - } - promise.resolve(available) - } catch (_: Exception) { - promise.resolve(false) - } - } - } - - override fun isNanoSupported(nano: ReadableMap?, promise: Promise) { - scope.launch { - try { - promise.resolve(runner.isNanoSupported(NanoConfig.from(nano))) - } catch (_: Exception) { - promise.resolve(false) - } - } - } - override fun getModelInfo(modelType: String, nano: ReadableMap?, promise: Promise) { scope.launch { try { diff --git a/packages/adk/src/NativeAdkEngine.ts b/packages/adk/src/NativeAdkEngine.ts index fa8e5f47..ba712924 100644 --- a/packages/adk/src/NativeAdkEngine.ts +++ b/packages/adk/src/NativeAdkEngine.ts @@ -146,11 +146,6 @@ export interface NanoDownloadProgressEvent { } export interface Spec extends TurboModule { - isAvailable( - modelType: AdkModelType, - nano?: AdkNanoModelConfig - ): Promise - isNanoSupported(nano?: AdkNanoModelConfig): Promise getModelInfo( modelType: AdkModelType, nano?: AdkNanoModelConfig diff --git a/packages/adk/src/__tests__/ai-sdk.test.ts b/packages/adk/src/__tests__/ai-sdk.test.ts index 4ec320d5..27875bf2 100644 --- a/packages/adk/src/__tests__/ai-sdk.test.ts +++ b/packages/adk/src/__tests__/ai-sdk.test.ts @@ -66,8 +66,6 @@ mock.module('react-native', () => ({ prepareNano, cancelStream, getModelInfo, - isNanoSupported: async () => true, - isAvailable: async () => true, onToolCall, submitToolResult, onStreamUpdate, @@ -137,36 +135,58 @@ describe('model resolution', () => { expect(nano.modelId).toBe('gemini-nano') }) - test('defaults cloud Gemini to gemini-2.5-flash', () => { - expect(gemini.modelId).toBe('gemini-2.5-flash') + test('defaults cloud Gemini to gemini-3.8-flash', () => { + expect(gemini.modelId).toBe('gemini-3.8-flash') + }) + + test('takes the model id as a model option', () => { + const provider = createAdkProvider({ model: 'gemini-3.5-flash-lite' }) + + expect(provider().modelId).toBe('gemini-3.5-flash-lite') + expect(provider({ modelName: 'gemini-nano' }).modelId).toBe('gemini-nano') }) test('infers cloud Gemini from a model name', async () => { - const model = createAdkProvider()('gemini-2.5-pro') + const model = createAdkProvider()('gemini-4-argon') await model.doGenerate(createCallOptions()) expect(lastGenerateCall()[2]).toMatchObject({ - model: { type: 'gemini', name: 'gemini-2.5-pro' }, + model: { type: 'gemini', name: 'gemini-4-argon' }, }) }) test('per-model options override provider defaults', () => { const provider = createAdkProvider({ instruction: 'Be brief.' }) - expect(provider({ modelName: 'gemini-2.5-pro' }).modelId).toBe( - 'gemini-2.5-pro' - ) + expect(provider({ model: 'gemini-4-argon' }).modelId).toBe('gemini-4-argon') expect(provider.languageModel().modelId).toBe('gemini-nano') }) test('reports model availability', async () => { expect(await createAdkProvider().getModelInfo()).toEqual({ + model: 'gemini-nano', modelType: 'genai-nano', - modelName: 'gemini-nano', availability: 'downloadable', + supportsTokenCounting: true, baseModelName: undefined, contextSize: undefined, }) }) + + test('reports availability for another model', async () => { + await createAdkProvider().getModelInfo({ model: 'gemini-3.8-flash' }) + + expect(getModelInfo.mock.calls.at(-1)![0]).toBe('gemini') + }) + + test('derives isAvailable from the model info', async () => { + const provider = createAdkProvider() + expect(await provider.isAvailable()).toBe(true) + + getModelInfo.mockImplementationOnce(async () => ({ + availability: 'downloading', + })) + expect(await provider.isAvailable()).toBe(false) + }) }) describe('prompt conversion', () => { @@ -692,7 +712,7 @@ describe('Gemini Nano preparation', () => { onNanoDownloadProgress.emit({ phase: 'completed' }) }) - await provider.prepareNano({ onProgress: (event) => progress.push(event) }) + await provider().prepare({ onProgress: (event) => progress.push(event) }) expect(progress).toEqual([ { phase: 'started', bytesDownloaded: undefined, bytesToDownload: 100 }, @@ -704,6 +724,18 @@ describe('Gemini Nano preparation', () => { ]) }) + test('keeps the deprecated prepareNano', async () => { + await createAdkProvider({ model: 'gemini-3.8-flash' }).prepareNano() + + expect(prepareNano).toHaveBeenCalledTimes(1) + }) + + test('does not prepare cloud models', async () => { + await gemini.prepare() + + expect(prepareNano).not.toHaveBeenCalled() + }) + test('passes the model selection to native code', async () => { const provider = createAdkProvider({ nano: { releaseStage: 'preview' } }) await provider().prepare() diff --git a/packages/adk/src/ai-sdk.ts b/packages/adk/src/ai-sdk.ts index 431f305c..b32e2613 100644 --- a/packages/adk/src/ai-sdk.ts +++ b/packages/adk/src/ai-sdk.ts @@ -40,7 +40,7 @@ import { import { StreamTextFilter, stripJsonFences } from './streamText' const DEFAULT_NANO_MODEL = 'gemini-nano' -const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash' +const DEFAULT_GEMINI_MODEL = 'gemini-3.8-flash' export type AdkToolDefinitionSet = Record @@ -48,9 +48,11 @@ export type AdkToolDefinitionSet = Record export type AdkLanguageModelId = 'gemini-nano' | (string & {}) export interface AdkLanguageModelOptions { - /** Defaults to `genai-nano`, or `gemini` when `modelName` names a cloud model */ + /** `gemini-nano` (default) runs on device, any other id is a cloud Gemini model */ + model?: AdkLanguageModelId + /** @deprecated Use `model`. Without a model, `gemini` uses `gemini-3.8-flash` */ modelType?: AdkModelType - /** Defaults to `gemini-nano` on device and `gemini-2.5-flash` in the cloud */ + /** @deprecated Use `model` */ modelName?: AdkLanguageModelId /** ADK agent name */ name?: string @@ -82,9 +84,11 @@ export type AdkModelAvailability = | 'unknown' export interface AdkModelInfo { + model: AdkLanguageModelId modelType: AdkModelType - modelName: string availability: AdkModelAvailability + /** Whether `countTokens` works, which only Gemini Nano supports */ + supportsTokenCounting: boolean /** Name of the Gemini Nano base model, when ML Kit reports it */ baseModelName?: string /** Gemini Nano input token limit, when ML Kit reports it */ @@ -102,8 +106,8 @@ export interface AdkPrepareOptions { } export interface AdkLanguageModel extends LanguageModelV4 { - /** Downloads and initializes Gemini Nano. No-op for cloud models */ - prepare: () => Promise + /** Downloads and initializes Gemini Nano, reporting progress. No-op for cloud models */ + prepare: (options?: AdkPrepareOptions) => Promise updateTools: (tools: AdkToolDefinitionSet) => void /** Counts tokens with the Gemini Nano tokenizer. Not available for cloud models */ countTokens: (text: string) => Promise @@ -115,47 +119,54 @@ export interface AdkProvider { languageModel: ( options?: AdkLanguageModelId | AdkLanguageModelOptions ) => AdkLanguageModel - /** Whether the device can run Gemini Nano at all. Returns `false` on non-Android */ - isNanoSupported: () => Promise /** - * Whether `modelType` can be used now. For `genai-nano`, Gemini Nano must be - * available or downloadable. Cloud `gemini` resolves to `true` on Android + * Whether the provider's model, or the default model of `modelType`, can be + * used now: its availability is `available` or `downloadable` */ isAvailable: (modelType?: AdkModelType) => Promise - /** Availability details for a model type */ + /** Availability details for the provider's model, or for `model` */ getModelInfo: (options?: { - modelType?: AdkModelType + model?: AdkLanguageModelId nano?: AdkNanoModelConfig }) => Promise - /** Downloads and initializes Gemini Nano, reporting download progress */ + /** @deprecated Check `(await getModelInfo()).availability` instead */ + isNanoSupported: () => Promise + /** @deprecated Use `prepare()` on a Gemini Nano model */ prepareNano: (options?: AdkPrepareOptions) => Promise } type ResolvedModelOptions = Omit< AdkLanguageModelOptions, - 'modelType' | 'modelName' + 'model' | 'modelType' | 'modelName' > & { + model: string modelType: AdkModelType - modelName: string } function resolveModelOptions( defaults: AdkLanguageModelOptions, options: AdkLanguageModelId | AdkLanguageModelOptions = {} ): ResolvedModelOptions { - const overrides = - typeof options === 'string' ? { modelName: options } : options - const merged = { ...defaults, ...overrides } + const overrides = typeof options === 'string' ? { model: options } : options + const { + model: defaultModel, + modelName: defaultModelName, + ...defaultRest + } = defaults + const { model, modelName, ...rest } = overrides + const merged = { ...defaultRest, ...rest } + const id = model ?? modelName ?? defaultModel ?? defaultModelName const modelType = merged.modelType ?? - (merged.modelName && merged.modelName !== DEFAULT_NANO_MODEL - ? 'gemini' - : 'genai-nano') - const modelName = - merged.modelName ?? - (modelType === 'gemini' ? DEFAULT_GEMINI_MODEL : DEFAULT_NANO_MODEL) - - return { ...merged, modelType, modelName } + (id && id !== DEFAULT_NANO_MODEL ? 'gemini' : 'genai-nano') + + return { + ...merged, + modelType, + model: + id ?? + (modelType === 'gemini' ? DEFAULT_GEMINI_MODEL : DEFAULT_NANO_MODEL), + } } const toModelAvailability = (value: string): AdkModelAvailability => { @@ -170,27 +181,48 @@ const toModelAvailability = (value: string): AdkModelAvailability => { } } -async function prepareNano( - nano: AdkNanoModelConfig | undefined, - options: AdkPrepareOptions = {} -) { - const native = getNativeAdkEngine() - const listener = options.onProgress - ? native.onNanoDownloadProgress((event: NanoDownloadProgressEvent) => { - options.onProgress?.({ - phase: event.phase as AdkDownloadProgress['phase'], - bytesDownloaded: event.bytesDownloaded, - bytesToDownload: event.bytesToDownload, - }) - }) +const listenForDownloadProgress = ( + onProgress: AdkPrepareOptions['onProgress'] +) => + onProgress + ? getNativeAdkEngine().onNanoDownloadProgress( + (event: NanoDownloadProgressEvent) => { + onProgress({ + phase: event.phase as AdkDownloadProgress['phase'], + bytesDownloaded: event.bytesDownloaded, + bytesToDownload: event.bytesToDownload, + }) + } + ) : null - try { - await native.prepareNano(nano) - } catch (error) { - throw toAdkError(error) - } finally { - listener?.remove() +async function getModelInfo( + { model, modelType }: ResolvedModelOptions, + nano: AdkNanoModelConfig | undefined +): Promise { + const supportsTokenCounting = modelType === 'genai-nano' + + if (Platform.OS !== 'android') { + return { + model, + modelType, + availability: 'unavailable', + supportsTokenCounting, + } + } + + const info = await getNativeAdkEngine() + .getModelInfo(modelType, nano) + .catch((error: unknown) => { + throw toAdkError(error) + }) + return { + model, + modelType, + availability: toModelAvailability(info.availability), + supportsTokenCounting, + baseModelName: info.baseModelName, + contextSize: info.contextSize, } } @@ -209,49 +241,34 @@ export function createAdkProvider( } provider.specificationVersion = 'v4' as const provider.languageModel = createLanguageModel - provider.isNanoSupported = async () => { - if (Platform.OS !== 'android') { - return false - } - return getNativeAdkEngine().isNanoSupported(defaults.nano) + provider.isAvailable = async (modelType?: AdkModelType) => { + const resolved = modelType + ? resolveModelOptions({}, { modelType }) + : resolveModelOptions(defaults) + const { availability } = await getModelInfo(resolved, defaults.nano) + return availability === 'available' || availability === 'downloadable' } - provider.isAvailable = async (modelType: AdkModelType = 'genai-nano') => { - if (Platform.OS !== 'android') { - return false - } - return getNativeAdkEngine() - .isAvailable(modelType, defaults.nano) - .then(Boolean) - } - provider.getModelInfo = async ( - options: { modelType?: AdkModelType; nano?: AdkNanoModelConfig } = {} - ): Promise => { - const resolved = resolveModelOptions(defaults) - const { modelType, modelName } = - options.modelType && options.modelType !== resolved.modelType - ? resolveModelOptions({ modelType: options.modelType }) - : resolved - const nano = options.nano ?? defaults.nano - - if (Platform.OS !== 'android') { - return { modelType, modelName, availability: 'unavailable' } - } - - const info = await getNativeAdkEngine() - .getModelInfo(modelType, nano) - .catch((error: unknown) => { - throw toAdkError(error) - }) - return { - modelType, - modelName, - availability: toModelAvailability(info.availability), - baseModelName: info.baseModelName, - contextSize: info.contextSize, - } + provider.getModelInfo = ( + options: { model?: AdkLanguageModelId; nano?: AdkNanoModelConfig } = {} + ) => + getModelInfo( + options.model + ? resolveModelOptions({}, options.model) + : resolveModelOptions(defaults), + options.nano ?? defaults.nano + ) + provider.isNanoSupported = async () => { + const { availability } = await getModelInfo( + resolveModelOptions({}, DEFAULT_NANO_MODEL), + defaults.nano + ) + return availability !== 'unavailable' && availability !== 'unknown' } provider.prepareNano = (options?: AdkPrepareOptions) => - prepareNano(defaults.nano, options) + createLanguageModel({ + model: DEFAULT_NANO_MODEL, + modelType: 'genai-nano', + }).prepare(options) return provider } @@ -468,14 +485,14 @@ class AdkChatLanguageModel implements AdkLanguageModel { private nanoPreparePromise: Promise | null = null constructor(options: ResolvedModelOptions) { - this.modelId = options.modelName + this.modelId = options.model this.agentConfig = { name: options.name ?? 'react_native_adk_agent', description: options.description ?? 'React Native ADK agent', instruction: options.instruction, model: { type: options.modelType, - name: options.modelName, + name: options.model, apiKey: options.apiKey, nano: options.nano, }, @@ -491,8 +508,17 @@ class AdkChatLanguageModel implements AdkLanguageModel { this.tools = tools } - async prepare(): Promise { - await this.ensureNanoPrepared() + async prepare(options: AdkPrepareOptions = {}): Promise { + if (!this.isNano) { + return + } + + const listener = listenForDownloadProgress(options.onProgress) + try { + await this.ensureNanoPrepared() + } finally { + listener?.remove() + } } async countTokens(text: string): Promise { @@ -519,12 +545,12 @@ class AdkChatLanguageModel implements AdkLanguageModel { } if (!this.nanoPreparePromise) { - this.nanoPreparePromise = prepareNano(this.agentConfig.model.nano).catch( - (error) => { + this.nanoPreparePromise = getNativeAdkEngine() + .prepareNano(this.agentConfig.model.nano) + .catch((error: unknown) => { this.nanoPreparePromise = null - throw error - } - ) + throw toAdkError(error) + }) } return this.nanoPreparePromise From 5674f836ec9cddd69729d28b9a3963061ab980d9 Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Thu, 29 Oct 2026 21:28:09 +0100 Subject: [PATCH 07/11] fix(adk): send gemini nano the whole prompt as one text part Gemini Nano reads only the first text part of an ML Kit request. ADK's GenaiPrompt sends one content per turn, and a separate system instruction that devices without system prompt support put first, so Nano answered the agent instruction and never saw the user's message. Merge every turn into one text part, after the system instruction when the device does not support one. Co-Authored-By: Claude Opus 5.5 --- .../com/callstack/ai/adk/AdkAgentRunner.kt | 4 +- .../callstack/ai/adk/NanoSingleTextPrompt.kt | 64 +++++++++++++++++++ 2 files changed, 67 insertions(+), 1 deletion(-) create mode 100644 packages/adk/android/src/main/java/com/callstack/ai/adk/NanoSingleTextPrompt.kt diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt index 91589ab8..8df65388 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt @@ -331,7 +331,9 @@ class AdkAgentRunner( private suspend fun createModel(config: AgentConfig): Model { return when (config.modelType) { "genai-nano" -> - NanoFunctionCallingModel(GenaiPrompt.create(preparedNano(config.nano), config.modelName)) + NanoFunctionCallingModel( + GenaiPrompt.create(NanoSingleTextPrompt(preparedNano(config.nano)), config.modelName), + ) else -> Gemini(name = config.modelName, apiKey = config.apiKey) } } diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/NanoSingleTextPrompt.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/NanoSingleTextPrompt.kt new file mode 100644 index 00000000..271f4541 --- /dev/null +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/NanoSingleTextPrompt.kt @@ -0,0 +1,64 @@ +package com.callstack.ai.adk + +import com.google.mlkit.genai.prompt.GenerateContentRequest +import com.google.mlkit.genai.prompt.GenerateContentResponse +import com.google.mlkit.genai.prompt.GenerativeModel +import com.google.mlkit.genai.prompt.ImagePart +import com.google.mlkit.genai.prompt.TextPart +import com.google.mlkit.genai.prompt.content +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.emitAll +import kotlinx.coroutines.flow.flow + +/** + * Wraps ML Kit's [GenerativeModel] so Gemini Nano sees the whole prompt. + * + * Gemini Nano reads only the first text part of a request. ADK's `GenaiPrompt` sends one content + * per turn, and a system instruction where the device has no system prompt support, so Nano + * answers the instruction and never sees the user's message. This merges the text of every turn + * into one part, after the system instruction when the device does not support one. Images stay + * as their own parts, before the text. + */ +internal class NanoSingleTextPrompt( + private val delegate: GenerativeModel, +) : GenerativeModel by delegate { + + @Volatile private var systemPromptAvailable: Boolean? = null + + override suspend fun generateContent(request: GenerateContentRequest): GenerateContentResponse = + delegate.generateContent(merge(request)) + + override fun generateContentStream(request: GenerateContentRequest): Flow = + flow { emitAll(delegate.generateContentStream(merge(request))) } + + private suspend fun merge(request: GenerateContentRequest): GenerateContentRequest { + val parts = request.contents.flatMap { it.parts } + val systemInstruction = request.systemInstruction?.takeUnless { supportsSystemPrompt() } + if (parts.size <= 1 && systemInstruction == null) { + return request + } + + val text = parts.filterIsInstance().joinToString("\n") { it.textString } + val images = parts.filterIsInstance() + val merged = TextPart(systemInstruction?.let { "${it.textString}\n\n$text" } ?: text) + return GenerateContentRequest.Builder(content { parts(*images.toTypedArray(), merged) }) + .apply { + if (systemInstruction == null) this.systemInstruction = request.systemInstruction + temperature = request.temperature + seed = request.seed + topK = request.topK + candidateCount = request.candidateCount + maxOutputTokens = request.maxOutputTokens + enableThinking = request.enableThinking + promptPrefix = request.promptPrefix + cachedContextName = request.cachedContextName + } + .build() + } + + private suspend fun supportsSystemPrompt(): Boolean = + systemPromptAvailable + ?: runCatching { delegate.isSystemPromptAvailable() } + .getOrDefault(false) + .also { systemPromptAvailable = it } +} From 7330c4fb6e76c0efdc9faa6e1c8fc63e05ddf340 Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Thu, 29 Oct 2026 22:06:56 +0100 Subject: [PATCH 08/11] refactor(adk)!: drop gemini nano tool calling and json workarounds ADK's ML Kit model has no tool calling, response schema or JSON mode for Gemini Nano. The provider worked around that by describing tools and schemas in the instruction, parsing tool_code blocks out of the text and stripping Markdown fences. Drop all of it: with Gemini Nano, tools and JSON response formats now return unsupported warnings, until ADK supports them. Co-Authored-By: Claude Opus 5.5 --- .../com/callstack/ai/adk/AdkAgentRunner.kt | 33 +--- .../ai/adk/NanoFunctionCallingModel.kt | 163 ------------------ .../callstack/ai/adk/NativeAdkEngineModule.kt | 2 +- .../ai/adk/ReactNativeFunctionTool.kt | 22 --- packages/adk/src/__tests__/ai-sdk.test.ts | 81 +++------ packages/adk/src/__tests__/streamText.test.ts | 56 ------ packages/adk/src/ai-sdk.ts | 53 ++---- packages/adk/src/streamText.ts | 92 ---------- 8 files changed, 48 insertions(+), 454 deletions(-) delete mode 100644 packages/adk/android/src/main/java/com/callstack/ai/adk/NanoFunctionCallingModel.kt delete mode 100644 packages/adk/src/__tests__/streamText.test.ts delete mode 100644 packages/adk/src/streamText.ts diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt index 8df65388..eeb32701 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt @@ -277,18 +277,11 @@ class AdkAgentRunner( val agentTools = parseTools(tools, runId) val model = createModel(agentConfig) val generateContentConfig = parseGenerationConfig(options) - val instructionText = - if (agentConfig.modelType == "genai-nano") { - buildInstruction(agentConfig.instruction, agentTools) - } else { - agentConfig.instruction - } - val agent = LlmAgent( name = agentConfig.name, description = agentConfig.description, model = model, - instruction = instructionText?.let { Instruction(it) }, + instruction = agentConfig.instruction?.let { Instruction(it) }, tools = agentTools, generateContentConfig = generateContentConfig, ) @@ -331,9 +324,7 @@ class AdkAgentRunner( private suspend fun createModel(config: AgentConfig): Model { return when (config.modelType) { "genai-nano" -> - NanoFunctionCallingModel( - GenaiPrompt.create(NanoSingleTextPrompt(preparedNano(config.nano)), config.modelName), - ) + GenaiPrompt.create(NanoSingleTextPrompt(preparedNano(config.nano)), config.modelName) else -> Gemini(name = config.modelName, apiKey = config.apiKey) } } @@ -478,26 +469,6 @@ class AdkAgentRunner( return parsed } - /** Gemini Nano has no native function calling, so its tools are described in the instruction. */ - private fun buildInstruction( - baseInstruction: String?, - tools: List, - ): String? { - if (tools.isEmpty()) { - return baseInstruction - } - - val toolGuidance = - "You have access to the following tools. Use them when they help answer the user:\n" + - tools.joinToString("\n") { it.promptDescription() } - - return if (baseInstruction.isNullOrBlank()) { - toolGuidance - } else { - "$baseInstruction\n\n$toolGuidance" - } - } - // JS always sends the name and model, with defaults applied private fun parseAgentConfig(config: ReadableMap): AgentConfig { fun ReadableMap.require(key: String) = diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/NanoFunctionCallingModel.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/NanoFunctionCallingModel.kt deleted file mode 100644 index 7ae69bf2..00000000 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/NanoFunctionCallingModel.kt +++ /dev/null @@ -1,163 +0,0 @@ -package com.callstack.ai.adk - -import com.google.adk.kt.models.LlmRequest -import com.google.adk.kt.models.LlmResponse -import com.google.adk.kt.models.Model -import com.google.adk.kt.mlkit.GenaiPrompt -import com.google.adk.kt.types.Content -import com.google.adk.kt.types.FunctionCall -import com.google.adk.kt.types.Part -import com.google.adk.kt.types.Role -import kotlinx.coroutines.flow.Flow -import kotlinx.coroutines.flow.map -import org.json.JSONException -import org.json.JSONObject -import java.util.UUID - -/** - * Wraps [GenaiPrompt] (Gemini Nano via ML Kit) to bridge text-based tool calling with ADK. - * - * Gemini Nano responds with ```tool_code ...``` blocks with tool calls. This wrapper: - * - * 1. Before each request: converts any [FunctionCall]/[FunctionResponse] parts (produced by - * previous turns) to plain text so that ML Kit can understand the multi-turn context. - * - * 2. After the final (non-partial) response: detects ```tool_code blocks in the text and converts - * each invocation to a proper [FunctionCall] part, allowing ADK's agent loop to execute the - * tools and continue the conversation. - */ -internal class NanoFunctionCallingModel(private val delegate: GenaiPrompt) : Model { - - override val name: String get() = delegate.name - - override fun generateContent(request: LlmRequest, stream: Boolean): Flow = - delegate.generateContent(prepareRequest(request), stream).map { response -> - if (response.partial) response else parseToolCodeBlocks(response) - } - - /** - * Request preparation: convert FunctionCall/FunctionResponse parts to text - */ - private fun prepareRequest(request: LlmRequest): LlmRequest { - val newContents = - request.contents.map { content -> - val newParts = - content.parts.flatMap { part -> - when { - part.functionCall != null -> { - val fc = part.functionCall!! - val argsText = - if (fc.args.isEmpty()) "" else runCatching { AdkJson.encode(fc.args) }.getOrElse { fc.args.toString() } - listOf(Part(text = "[Tool call: ${fc.name}($argsText)]")) - } - part.functionResponse != null -> { - val fr = part.functionResponse!! - val responseMap = - fr.response - .filterValues { it != null } - .mapValues { (_, v) -> v as Any } - val resultText = - if (responseMap.isEmpty()) "{}" - else runCatching { AdkJson.encode(responseMap) }.getOrElse { responseMap.toString() } - listOf(Part(text = "[Tool result for ${fr.name}: $resultText]")) - } - else -> listOf(part) - } - } - content.copy(parts = newParts) - } - return request.copy(contents = newContents) - } - - /** - * Response post-processing: convert ```tool_code blocks to FunctionCall parts - */ - private fun parseToolCodeBlocks(response: LlmResponse): LlmResponse { - val content = response.content ?: return response - val newParts = mutableListOf() - var hasToolCalls = false - - for (part in content.parts) { - val text = part.text - if (text == null) { - newParts.add(part) - continue - } - - val calls = extractToolCalls(text) - if (calls.isEmpty()) { - newParts.add(part) - continue - } - - hasToolCalls = true - val surrounding = removeToolCodeBlocks(text).trim() - if (surrounding.isNotEmpty()) { - newParts.add(Part(text = surrounding)) - } - for (call in calls) { - newParts.add(Part(functionCall = call)) - } - } - - if (!hasToolCalls) return response - return response.copy(content = Content(role = Role.MODEL, parts = newParts)) - } - - private fun extractToolCalls(text: String): List { - val calls = mutableListOf() - val blockRegex = Regex("```tool_code\\s*\\n([\\s\\S]*?)\\n?```") - for (block in blockRegex.findAll(text)) { - val code = block.groupValues[1] - for (line in code.lines()) { - val trimmed = line.trim() - if (trimmed.isNotEmpty()) { - parseFunctionCall(trimmed)?.let { calls.add(it) } - } - } - } - return calls - } - - private fun removeToolCodeBlocks(text: String): String = - Regex("```tool_code\\s*\\n[\\s\\S]*?\\n?```").replace(text, "") - - /** - * Parses a single call line such as: - * - `functionName()` - * - `functionName({"key": "value"})` - * - `print(functionName(...))` (some models wrap in print) - */ - private fun parseFunctionCall(code: String): FunctionCall? { - // Regex: outer function name + everything between the outermost parens (greedy) - val callRegex = Regex("""^([A-Za-z_][A-Za-z0-9_]*)\s*\(([\s\S]*)\)\s*$""") - val outer = callRegex.find(code) ?: return null - val outerName = outer.groupValues[1] - val outerArgs = outer.groupValues[2] - - val (name, argsStr) = - if (outerName == "print") { - val inner = callRegex.find(outerArgs.trim()) ?: return null - inner.groupValues[1] to inner.groupValues[2] - } else { - outerName to outerArgs - } - - if (name.isBlank()) return null - - val args: Map = - if (argsStr.isBlank()) { - emptyMap() - } else { - val jsonStr = argsStr.trim().let { if (it.startsWith("{")) it else "{$it}" } - try { - val jsonObj = JSONObject(jsonStr) - jsonObj.keys().asSequence().associateWith { key -> jsonObj.get(key) as Any } - } catch (_: JSONException) { - emptyMap() - } - } - - return FunctionCall(name = name, args = args, id = UUID.randomUUID().toString()) - } -} diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt index 715a36e4..abfae1e2 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt @@ -171,7 +171,7 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : var partialUsage: UsageMetadata? = null // ADK may deliver text cumulatively (each event repeats the turn so far) or as // deltas, so the turn text is rebuilt here and only the new part is sent to JS. - // JS hides Gemini Nano tool_code blocks. Reasoning is tracked the same way. + // Reasoning is tracked the same way. var currentTurnText = "" var emittedText = "" var currentTurnReasoning = "" diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt index fe9289b5..0b0d3b63 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt @@ -29,28 +29,6 @@ class ReactNativeFunctionTool( parameters = parameterSchema ?: Schema(type = Type.OBJECT), ) - /** Describes the tool for models without native function calling. */ - fun promptDescription(): String { - val parameters = declaration().parameters - val parameterLines = - parameters?.properties?.entries?.joinToString("\n") { (paramName, paramSchema) -> - val paramType = paramSchema.type?.name?.lowercase() ?: "string" - val paramDescription = paramSchema.description?.let { " — $it" } ?: "" - val required = parameters.required?.contains(paramName) == true - " - $paramName ($paramType, required=$required)$paramDescription" - } ?: "" - - return buildString { - append("- $name") - if (description.isNotBlank()) { - append(": $description") - } - if (parameterLines.isNotBlank()) { - append("\n Parameters:\n$parameterLines") - } - } - } - override suspend fun execute(context: ToolContext, args: Map): Any { // Use ADK's id so JS sees the same id as the reported tool call val toolCallId = context.functionCallId ?: UUID.randomUUID().toString() diff --git a/packages/adk/src/__tests__/ai-sdk.test.ts b/packages/adk/src/__tests__/ai-sdk.test.ts index 27875bf2..55282d3b 100644 --- a/packages/adk/src/__tests__/ai-sdk.test.ts +++ b/packages/adk/src/__tests__/ai-sdk.test.ts @@ -467,20 +467,26 @@ describe('generation options', () => { }) }) - test('puts the response schema in the Gemini Nano instruction', async () => { + test('warns that Gemini Nano has no JSON mode', async () => { const schema = { type: 'object', properties: { name: { type: 'string' } } } - await nano.doGenerate( + const result = await nano.doGenerate( createCallOptions({ responseFormat: { type: 'json', schema } }) ) const [, , config, options] = lastGenerateCall() as [ string, unknown, - { instruction: string }, - { responseFormat: { schema?: unknown } }, + { instruction?: string }, + { responseFormat?: unknown }, ] - expect(config.instruction).toContain(JSON.stringify(schema)) - expect(options.responseFormat.schema).toBe(undefined) + expect(config.instruction).toBe(undefined) + expect(options.responseFormat).toBe(undefined) + expect(result.warnings).toContainEqual( + expect.objectContaining({ + type: 'unsupported', + feature: 'responseFormat', + }) + ) }) test('warns about settings Gemini Nano ignores', async () => { @@ -546,16 +552,6 @@ describe('doGenerate results', () => { }) }) - test('strips Markdown fences from JSON output', async () => { - generateTextResult = { content: '```json\n{"a":1}\n```' } - - const result = await nano.doGenerate( - createCallOptions({ responseFormat: { type: 'json' } }) - ) - - expect(result.content).toEqual([{ type: 'text', text: '{"a":1}' }]) - }) - test('maps safety finish reasons to content-filter', async () => { generateTextResult = { content: '', finishReason: 'SAFETY' } @@ -644,47 +640,24 @@ describe('doStream', () => { }) }) - test('streams JSON without Markdown fences', async () => { - const parts = await runStream( - createCallOptions({ responseFormat: { type: 'json' } }), - (streamId) => { - for (const delta of ['``', '`json\n{"a"', ':1}', '\n`', '``']) { - onStreamUpdate.emit({ streamId, delta }) - } - onStreamComplete.emit({ streamId }) - }, - nano + test('warns that Gemini Nano has no tool calling', async () => { + const result = await nano.doGenerate( + createCallOptions({ + tools: [ + { + type: 'function', + name: 'getWeather', + inputSchema: { type: 'object', properties: {} }, + }, + ], + }) ) - const text = parts - .flatMap((part) => (part.type === 'text-delta' ? [part.delta] : [])) - .join('') - expect(text).toBe('{"a":1}') - }) - - test('hides Gemini Nano tool_code text and streams the next turn', async () => { - const parts = await runStream( - createCallOptions(), - (streamId) => { - for (const delta of ['Checking.\n``', '`tool_code\nf()\n```']) { - onStreamUpdate.emit({ streamId, delta }) - } - onStreamToolCall.emit({ - streamId, - phase: 'start', - toolCallId: '1', - toolName: 'f', - }) - onStreamUpdate.emit({ streamId, delta: 'Done.' }) - onStreamComplete.emit({ streamId }) - }, - nano + const [, , , , tools] = lastGenerateCall() as unknown[] + expect(tools).toEqual([]) + expect(result.warnings).toContainEqual( + expect.objectContaining({ type: 'unsupported', feature: 'tools' }) ) - - const text = parts - .flatMap((part) => (part.type === 'text-delta' ? [part.delta] : [])) - .join('') - expect(text).toBe('Checking.\nDone.') }) test('surfaces native stream errors with their code', async () => { diff --git a/packages/adk/src/__tests__/streamText.test.ts b/packages/adk/src/__tests__/streamText.test.ts deleted file mode 100644 index 6714bc81..00000000 --- a/packages/adk/src/__tests__/streamText.test.ts +++ /dev/null @@ -1,56 +0,0 @@ -import { describe, expect, test } from 'bun:test' - -import { StreamTextFilter } from '../streamText' - -function run( - deltas: string[], - options: { json?: boolean; toolCode?: boolean } = {} -) { - const filter = new StreamTextFilter({ - json: options.json ?? false, - toolCode: options.toolCode ?? false, - }) - const shown = deltas.map((delta) => filter.push(delta)) - return { shown, text: shown.join('') + filter.flush() } -} - -describe('StreamTextFilter', () => { - test('passes plain text through', () => { - expect(run(['Hel', 'lo']).shown).toEqual(['Hel', 'lo']) - }) - - test('hides a tool_code block split across deltas', () => { - const { shown, text } = run( - ['Let me check.\n``', '`tool_', 'code\ngetWeather()\n```'], - { toolCode: true } - ) - - expect(shown).toEqual(['Let me check.\n', '', '']) - expect(text).toBe('Let me check.\n') - }) - - test('shows held back backticks that are not a tool_code block', () => { - const { shown, text } = run(['Use ``', 'x`` here'], { toolCode: true }) - - expect(shown).toEqual(['Use ', '``x`` here']) - expect(text).toBe('Use ``x`` here') - }) - - test('starts a new turn after a tool call', () => { - const filter = new StreamTextFilter({ json: false, toolCode: true }) - filter.push('```tool_code\nf()\n```') - filter.endTurn() - - expect(filter.push('Done.')).toBe('Done.') - }) - - test('leaves tool_code text alone for other models', () => { - expect(run(['```tool_code\nf()\n```']).text).toBe('```tool_code\nf()\n```') - }) - - test('strips JSON code fences', () => { - expect( - run(['``', '`json\n{"a"', ':1}', '\n`', '``'], { json: true }).text - ).toBe('{"a":1}') - }) -}) diff --git a/packages/adk/src/ai-sdk.ts b/packages/adk/src/ai-sdk.ts index b32e2613..1bbf3e13 100644 --- a/packages/adk/src/ai-sdk.ts +++ b/packages/adk/src/ai-sdk.ts @@ -37,7 +37,6 @@ import { type StreamToolCallEvent, type ToolCallEvent, } from './NativeAdkEngine' -import { StreamTextFilter, stripJsonFences } from './streamText' const DEFAULT_NANO_MODEL = 'gemini-nano' const DEFAULT_GEMINI_MODEL = 'gemini-3.8-flash' @@ -466,11 +465,6 @@ const parseToolResult = (output: string): NonNullable => { } } -const createNanoJsonInstruction = (schema: unknown) => - schema - ? `Respond only with JSON that matches this JSON schema, without Markdown or other text:\n${JSON.stringify(schema)}` - : 'Respond only with valid JSON, without Markdown or other text.' - class AdkChatLanguageModel implements AdkLanguageModel { readonly specificationVersion = 'v4' readonly supportedUrls = { @@ -642,21 +636,11 @@ class AdkChatLanguageModel implements AdkLanguageModel { const systemPrompts = options.prompt.flatMap((message) => message.role === 'system' ? [message.content] : [] ) - // Gemini Nano has no response schema, so the schema goes in the instruction - const jsonInstruction = - this.isNano && options.responseFormat?.type === 'json' - ? createNanoJsonInstruction(options.responseFormat.schema) - : undefined - - if (systemPrompts.length === 0 && !jsonInstruction) { + if (systemPrompts.length === 0) { return this.agentConfig } - const instruction = [ - this.agentConfig.instruction, - ...systemPrompts, - jsonInstruction, - ] + const instruction = [this.agentConfig.instruction, ...systemPrompts] .filter(Boolean) .join('\n\n') @@ -678,6 +662,9 @@ class AdkChatLanguageModel implements AdkLanguageModel { stopSequences: options.stopSequences, presencePenalty: options.presencePenalty, frequencyPenalty: options.frequencyPenalty, + // ADK's ML Kit model has no response schema or JSON mode + responseFormat: + options.responseFormat?.type === 'json' ? 'json' : undefined, } for (const [feature, value] of Object.entries(unsupported)) { if (value !== undefined) { @@ -700,11 +687,11 @@ class AdkChatLanguageModel implements AdkLanguageModel { presencePenalty: options.presencePenalty, frequencyPenalty: options.frequencyPenalty, responseFormat: - options.responseFormat?.type === 'json' + options.responseFormat?.type === 'json' && !this.isNano ? { type: 'json', mimeType: 'application/json', - schema: this.isNano ? undefined : options.responseFormat.schema, + schema: options.responseFormat.schema, } : undefined, thinking: prepareThinking(options.reasoning, adkOptions), @@ -712,6 +699,15 @@ class AdkChatLanguageModel implements AdkLanguageModel { } private prepareTools(tools: Tool[], warnings: SharedV4Warning[]) { + if (this.isNano && tools.length > 0) { + warnings.push({ + type: 'unsupported', + feature: 'tools', + details: "ADK's ML Kit model has no tool calling for Gemini Nano.", + }) + return [] + } + const functionTools = tools.filter( (tool): tool is LanguageModelV4FunctionTool => { if (tool.type === 'function') { @@ -872,13 +868,7 @@ class AdkChatLanguageModel implements AdkLanguageModel { result: parseToolResult(toolResult.output), }) } - content.push({ - type: 'text', - text: - options.responseFormat?.type === 'json' - ? stripJsonFences(response.content) - : response.content, - }) + content.push({ type: 'text', text: response.content }) return { content, @@ -909,7 +899,6 @@ class AdkChatLanguageModel implements AdkLanguageModel { const streamId = generateId() const native = getNativeAdkEngine() const abortSignal = options.abortSignal - const isJson = options.responseFormat?.type === 'json' if (typeof ReadableStream === 'undefined') { throw new Error( @@ -953,10 +942,6 @@ class AdkChatLanguageModel implements AdkLanguageModel { let textOpen = false let reasoningId: string | undefined let reasoningCount = 0 - const textFilter = new StreamTextFilter({ - json: isJson, - toolCode: this.isNano, - }) const addListener = (listener: { remove(): void }) => { listeners.push(listener) @@ -1009,7 +994,7 @@ class AdkChatLanguageModel implements AdkLanguageModel { return } - emitText(textFilter.push(data.delta)) + emitText(data.delta) }) ) @@ -1021,7 +1006,6 @@ class AdkChatLanguageModel implements AdkLanguageModel { if (data.phase === 'start' && data.toolName) { closeReasoning() - textFilter.endTurn() toolNames.set(data.toolCallId, data.toolName) controller.enqueue({ type: 'tool-input-start', @@ -1073,7 +1057,6 @@ class AdkChatLanguageModel implements AdkLanguageModel { if (data.streamId !== streamId) { return } - emitText(textFilter.flush()) closeReasoning() if (textOpen) { controller.enqueue({ type: 'text-end', id: textId }) diff --git a/packages/adk/src/streamText.ts b/packages/adk/src/streamText.ts deleted file mode 100644 index 1dc20fcf..00000000 --- a/packages/adk/src/streamText.ts +++ /dev/null @@ -1,92 +0,0 @@ -// Gemini Nano writes tool calls as text, which ADK turns into function calls -const toolCodeMarker = '```tool_code' - -// Gemini Nano often wraps JSON in a Markdown code fence -const jsonFencePrefix = /^\s*```(?:json)?\s*\n?/ -// Text that could still grow into the opening fence -const partialJsonFence = /^\s*`{0,3}(j(s(o(n)?)?)?)?$/ - -export const stripJsonFences = (text: string) => - text.replace(jsonFencePrefix, '').replace(/\s*```\s*$/, '') - -// Length of the end of `text` that could be the start of `marker` -function pendingPrefixLength(text: string, marker: string) { - for ( - let length = Math.min(text.length, marker.length - 1); - length > 0; - length-- - ) { - if (marker.startsWith(text.slice(-length))) { - return length - } - } - return 0 -} - -/** - * Filters streamed model text. It hides Gemini Nano `tool_code` blocks and, in - * JSON mode, Markdown code fences, holding back text until it cannot become one. - */ -export class StreamTextFilter { - private turnText = '' - private emitted = '' - - constructor(private readonly options: { json: boolean; toolCode: boolean }) {} - - /** Adds a text delta and returns the text that is now safe to show */ - push(delta: string) { - this.turnText += delta - return this.take(false) - } - - /** Returns the rest of the text at the end of the stream */ - flush() { - return this.take(true) - } - - /** A tool call ended the model turn, so the next turn starts empty */ - endTurn() { - this.turnText = '' - this.emitted = '' - } - - private take(final: boolean) { - const visible = this.visibleText(final) - if (visible === undefined || !visible.startsWith(this.emitted)) { - return '' - } - const delta = visible.slice(this.emitted.length) - this.emitted = visible - return delta - } - - private visibleText(final: boolean): string | undefined { - let text = this.turnText - const markerIndex = this.options.toolCode - ? text.indexOf(toolCodeMarker) - : -1 - if (markerIndex !== -1) { - text = text.slice(0, markerIndex) - } - - if (this.options.json) { - if (final) { - return stripJsonFences(text) - } - if (partialJsonFence.test(text)) { - return undefined - } - // Hold back trailing backticks that could start a closing fence - text = text.replace(jsonFencePrefix, '').replace(/\s*`{1,3}$/, '') - } - - // Hold back the end of the text while it could still become the marker - if (this.options.toolCode && markerIndex === -1 && !final) { - text = text.slice( - 0, - text.length - pendingPrefixLength(text, toolCodeMarker) - ) - } - return text - } -} From 55d19ad5eaa2c8f972471c6c4e7ea32efd1d17fb Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Thu, 29 Oct 2026 22:52:27 +0100 Subject: [PATCH 09/11] refactor(adk)!: make the provider gemini nano only Google's Gen AI SDK, which ADK's Gemini model uses, refuses API keys on Android and points to Firebase AI Logic, so cloud Gemini never worked in an app. Drop it, with the tool calling, structured output and tool bridge only cloud Gemini used, and the modelType, modelName, model and apiKey options. Remove the deprecated isNanoSupported and prepareNano too: the provider was never released, so prepare() and getModelInfo() replace them outright. Tools, JSON output and the settings Gemini Nano ignores return unsupported warnings. Co-Authored-By: Claude Opus 5.5 --- .../com/callstack/ai/adk/AdkAgentRunner.kt | 160 +---- .../java/com/callstack/ai/adk/AdkErrors.kt | 10 +- .../main/java/com/callstack/ai/adk/AdkJson.kt | 63 -- .../java/com/callstack/ai/adk/AdkSchema.kt | 109 ---- .../callstack/ai/adk/AdkStreamToolCalls.kt | 119 ---- .../com/callstack/ai/adk/AdkToolBridge.kt | 39 -- .../java/com/callstack/ai/adk/AdkUsage.kt | 5 +- .../callstack/ai/adk/NativeAdkEngineModule.kt | 69 +-- .../ai/adk/ReactNativeFunctionTool.kt | 41 -- packages/adk/src/NativeAdkEngine.ts | 74 +-- packages/adk/src/__tests__/ai-sdk.test.ts | 375 +++--------- packages/adk/src/ai-sdk.ts | 552 ++---------------- packages/adk/src/errors.ts | 1 - packages/adk/src/index.ts | 4 - 14 files changed, 156 insertions(+), 1465 deletions(-) delete mode 100644 packages/adk/android/src/main/java/com/callstack/ai/adk/AdkJson.kt delete mode 100644 packages/adk/android/src/main/java/com/callstack/ai/adk/AdkSchema.kt delete mode 100644 packages/adk/android/src/main/java/com/callstack/ai/adk/AdkStreamToolCalls.kt delete mode 100644 packages/adk/android/src/main/java/com/callstack/ai/adk/AdkToolBridge.kt delete mode 100644 packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt index eeb32701..2e7a0275 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkAgentRunner.kt @@ -11,8 +11,6 @@ import com.google.adk.kt.agents.RunConfig import com.google.adk.kt.agents.StreamingMode import com.google.adk.kt.events.Event import com.google.adk.kt.mlkit.GenaiPrompt -import com.google.adk.kt.models.Gemini -import com.google.adk.kt.models.Model import com.google.adk.kt.runners.InMemoryRunner import com.google.adk.kt.sessions.InMemorySessionService import com.google.adk.kt.sessions.SessionKey @@ -41,15 +39,9 @@ import kotlinx.coroutines.sync.withLock import java.util.UUID import java.util.concurrent.ConcurrentHashMap -data class AdkToolCallRecord(val toolCallId: String, val toolName: String, val input: String) - -data class AdkToolResultRecord(val toolCallId: String, val toolName: String, val output: String) - data class AdkRunResult( val content: String, val reasoning: String?, - val toolCalls: List, - val toolResults: List, val finishReason: String?, val usage: UsageMetadata?, ) @@ -82,12 +74,6 @@ fun Event.textParts(thoughts: Boolean): String = class AdkAgentRunner( private val context: Context, - private val onToolCall: ( - runId: String, - toolCallId: String, - toolName: String, - arguments: String, - ) -> Unit, private val onDownloadProgress: ( phase: String, bytesDownloaded: Long?, @@ -171,11 +157,7 @@ class AdkAgentRunner( return nanoModels.getValue(config) } - suspend fun getModelInfo(modelType: String, config: NanoConfig): AdkModelInfo { - if (modelType != "genai-nano") { - return AdkModelInfo(availability = "available") - } - + suspend fun getModelInfo(config: NanoConfig): AdkModelInfo { val model = nanoClient(config) val status = try { @@ -205,10 +187,8 @@ class AdkAgentRunner( messages: ReadableArray, config: ReadableMap, options: ReadableMap?, - tools: ReadableArray?, - runId: String, ): AdkRunResult { - val events = runAgent(messages, config, options, tools, stream = false, runId = runId).toList() + val events = runAgent(messages, config, options, stream = false).toList() val completeEvents = events.filterNot { it.partial } val text = completeEvents @@ -223,32 +203,9 @@ class AdkAgentRunner( .joinToString("\n\n") .ifEmpty { null } - val toolCalls = - completeEvents.flatMap { event -> - event.functionCalls().map { call -> - AdkToolCallRecord( - toolCallId = call.id ?: UUID.randomUUID().toString(), - toolName = call.name, - input = AdkJson.encode(call.args), - ) - } - } - val toolResults = - completeEvents.flatMap { event -> - event.functionResponses().map { response -> - AdkToolResultRecord( - toolCallId = response.id ?: "", - toolName = response.name, - output = AdkJson.encode(response.response), - ) - } - } - return AdkRunResult( content = text, reasoning = reasoning, - toolCalls = toolCalls, - toolResults = toolResults, finishReason = events.lastOrNull()?.finishReason?.name, usage = AdkUsage.fromEvents(events), ) @@ -258,32 +215,24 @@ class AdkAgentRunner( messages: ReadableArray, config: ReadableMap, options: ReadableMap?, - tools: ReadableArray?, - runId: String, ): Flow { - return runAgent(messages, config, options, tools, stream = true, runId = runId) + return runAgent(messages, config, options, stream = true) } private suspend fun runAgent( messages: ReadableArray, config: ReadableMap, options: ReadableMap?, - tools: ReadableArray?, stream: Boolean, - runId: String, ): Flow { val parsedMessages = parseMessages(messages) val agentConfig = parseAgentConfig(config) - val agentTools = parseTools(tools, runId) - val model = createModel(agentConfig) - val generateContentConfig = parseGenerationConfig(options) val agent = LlmAgent( name = agentConfig.name, description = agentConfig.description, - model = model, + model = GenaiPrompt.create(NanoSingleTextPrompt(preparedNano(agentConfig.nano))), instruction = agentConfig.instruction?.let { Instruction(it) }, - tools = agentTools, - generateContentConfig = generateContentConfig, + generateContentConfig = parseGenerationConfig(options), ) val sessionService = InMemorySessionService() @@ -321,37 +270,10 @@ class AdkAgentRunner( ) } - private suspend fun createModel(config: AgentConfig): Model { - return when (config.modelType) { - "genai-nano" -> - GenaiPrompt.create(NanoSingleTextPrompt(preparedNano(config.nano)), config.modelName) - else -> Gemini(name = config.modelName, apiKey = config.apiKey) - } - } - + /** ADK's ML Kit model passes on temperature, topK, maxOutputTokens and thinking. */ private fun parseGenerationConfig(options: ReadableMap?): GenerateContentConfig? { if (options == null) return null - val responseFormat = options.getMap("responseFormat") - val responseSchema = - responseFormat?.getMap("schema")?.let { schema -> - try { - AdkSchema.fromReadableMap(schema) - } catch (error: Exception) { - throw AdkErrors.AdkException( - AdkErrors.INVALID_SCHEMA, - "Unsupported response schema: ${error.message}", - error, - ) - } - } - - val responseMimeType = when { - responseFormat?.hasKey("mimeType") == true -> responseFormat.getString("mimeType") - responseFormat?.getString("type") == "json" -> "application/json" - else -> null - } - val thinkingConfig = options.getMap("thinking")?.let { thinking -> ThinkingConfig( @@ -363,19 +285,7 @@ class AdkAgentRunner( return GenerateContentConfig( temperature = options.takeIf { it.hasKey("temperature") }?.getDouble("temperature")?.toFloat(), maxOutputTokens = options.takeIf { it.hasKey("maxTokens") }?.getInt("maxTokens"), - topP = options.takeIf { it.hasKey("topP") }?.getDouble("topP")?.toFloat(), topK = options.takeIf { it.hasKey("topK") }?.getDouble("topK")?.toFloat()?.toInt(), - seed = options.takeIf { it.hasKey("seed") }?.getDouble("seed")?.toInt(), - stopSequences = - options.getArray("stopSequences")?.let { array -> - (0 until array.size()).mapNotNull { index -> array.getString(index) } - }, - presencePenalty = - options.takeIf { it.hasKey("presencePenalty") }?.getDouble("presencePenalty")?.toFloat(), - frequencyPenalty = - options.takeIf { it.hasKey("frequencyPenalty") }?.getDouble("frequencyPenalty")?.toFloat(), - responseMimeType = responseMimeType, - responseSchema = responseSchema, thinkingConfig = thinkingConfig, ) } @@ -435,67 +345,21 @@ class AdkAgentRunner( context.contentResolver.openInputStream(Uri.parse(uri))?.use { it.readBytes() } ?: throw IllegalArgumentException("Cannot read file: $uri") - private fun parseTools(tools: ReadableArray?, runId: String): List { - if (tools == null) return emptyList() - - val parsed = mutableListOf() - for (index in 0 until tools.size()) { - val tool = tools.getMap(index) ?: continue - val name = tool.getString("name") ?: continue - val parameterSchema = - tool.getMap("inputSchema")?.let { schemaMap -> - try { - AdkSchema.fromReadableMap(schemaMap) - } catch (error: Exception) { - throw AdkErrors.AdkException( - AdkErrors.INVALID_SCHEMA, - "Unsupported input schema for tool $name: ${error.message}", - error, - ) - } - } - - parsed.add( - ReactNativeFunctionTool( - name = name, - description = tool.getString("description") ?: "", - parameterSchema = parameterSchema, - runId = runId, - onToolCall = onToolCall, - ) - ) - } - - return parsed - } - - // JS always sends the name and model, with defaults applied - private fun parseAgentConfig(config: ReadableMap): AgentConfig { - fun ReadableMap.require(key: String) = - getString(key) ?: throw IllegalArgumentException("Agent config requires $key") - - val model = config.getMap("model") - ?: throw IllegalArgumentException("Agent config requires a model") - - return AgentConfig( - name = config.require("name"), + // JS always sends the name, with defaults applied + private fun parseAgentConfig(config: ReadableMap): AgentConfig = + AgentConfig( + name = config.getString("name") + ?: throw IllegalArgumentException("Agent config requires a name"), description = config.getString("description") ?: "", instruction = config.getString("instruction"), - modelType = model.require("type"), - modelName = model.require("name"), - apiKey = model.getString("apiKey"), - nano = NanoConfig.from(model.getMap("nano")), + nano = NanoConfig.from(config.getMap("nano")), ) - } } data class AgentConfig( val name: String, val description: String, val instruction: String?, - val modelType: String, - val modelName: String, - val apiKey: String?, val nano: NanoConfig, ) diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkErrors.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkErrors.kt index 107478c3..790d980a 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkErrors.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkErrors.kt @@ -10,7 +10,6 @@ object AdkErrors { const val DOWNLOAD_FAILED = "DOWNLOAD_FAILED" const val GENERATION_ERROR = "GENERATION_ERROR" const val INVALID_MESSAGE = "INVALID_MESSAGE" - const val INVALID_SCHEMA = "INVALID_SCHEMA" const val CONTEXT_WINDOW_EXCEEDED = "CONTEXT_WINDOW_EXCEEDED" const val RATE_LIMITED = "RATE_LIMITED" const val BACKGROUND_USE_BLOCKED = "BACKGROUND_USE_BLOCKED" @@ -29,14 +28,7 @@ object AdkErrors { } current = current.cause } - - // Cloud Gemini surfaces HTTP status codes in the message - val message = error.message.orEmpty() - return when { - message.contains("RESOURCE_EXHAUSTED") || message.contains("429") -> RATE_LIMITED - message.contains("exceeds the maximum number of tokens") -> CONTEXT_WINDOW_EXCEEDED - else -> GENERATION_ERROR - } + return GENERATION_ERROR } private fun codeFor(error: GenAiException): String = diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkJson.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkJson.kt deleted file mode 100644 index 91cd71b0..00000000 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkJson.kt +++ /dev/null @@ -1,63 +0,0 @@ -package com.callstack.ai.adk - -import org.json.JSONArray -import org.json.JSONObject -import org.json.JSONTokener - -object AdkJson { - fun encode(value: Map): String { - return mapToJsonObject(value).toString() - } - - /** Decodes a tool result, which JS always sends as JSON. */ - fun decodeResult(value: String): Any? = jsonValue(JSONTokener(value).nextValue()) - - private fun mapToJsonObject(value: Map): JSONObject { - val json = JSONObject() - value.forEach { (key, entryValue) -> - json.put(key, toJsonValue(entryValue)) - } - return json - } - - private fun toJsonValue(value: Any?): Any? { - return when (value) { - null -> JSONObject.NULL - is Map<*, *> -> { - @Suppress("UNCHECKED_CAST") - mapToJsonObject(value as Map) - } - is Iterable<*> -> { - val array = JSONArray() - value.forEach { item -> array.put(toJsonValue(item)) } - array - } - else -> value - } - } - - private fun jsonObjectToMap(json: JSONObject): Map { - val result = mutableMapOf() - json.keys().forEach { key -> - result[key] = jsonValue(json.get(key)) - } - return result - } - - private fun jsonArrayToList(json: JSONArray): List { - val result = mutableListOf() - for (index in 0 until json.length()) { - result.add(jsonValue(json.get(index))) - } - return result - } - - private fun jsonValue(value: Any?): Any? { - return when (value) { - JSONObject.NULL, null -> null - is JSONObject -> jsonObjectToMap(value) - is JSONArray -> jsonArrayToList(value) - else -> value - } - } -} diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkSchema.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkSchema.kt deleted file mode 100644 index a0c45b10..00000000 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkSchema.kt +++ /dev/null @@ -1,109 +0,0 @@ -package com.callstack.ai.adk - -import com.facebook.react.bridge.ReadableArray -import com.facebook.react.bridge.ReadableMap -import com.facebook.react.bridge.ReadableType -import com.google.adk.kt.types.Schema -import com.google.adk.kt.types.Type - -/** - * Converts a JSON Schema from the AI SDK to an ADK [Schema]. Keywords that Gemini does not - * support, such as `$ref` or `additionalProperties`, are dropped. - */ -object AdkSchema { - fun fromReadableMap(map: ReadableMap): Schema { - val properties = map.getMap("properties")?.let { props -> - val result = mutableMapOf() - val iterator = props.keySetIterator() - while (iterator.hasNextKey()) { - val key = iterator.nextKey() - props.getMap(key)?.let { result[key] = fromReadableMap(it) } - } - result - } - - val required = map.getArray("required")?.let { array -> - (0 until array.size()).mapNotNull { index -> array.getString(index) } - } - - val enumValues = map.getArray("enum")?.let { array -> - (0 until array.size()).mapNotNull { index -> - when (array.getType(index)) { - ReadableType.String -> array.getString(index) - ReadableType.Number -> array.getDouble(index).toString() - ReadableType.Boolean -> array.getBoolean(index).toString() - else -> null - } - } - } - - // `type: ["string", "null"]` and `anyOf: [..., { type: "null" }]` both mean nullable - val typeNames = readTypeNames(map) - var nullable = typeNames.contains("null") || map.getBooleanOrNull("nullable") == true - val type = typeNames.firstOrNull { it != "null" }?.let { parseType(it) } - - val anyOf = (map.getArray("anyOf") ?: map.getArray("oneOf"))?.let { array -> - val schemas = (0 until array.size()).mapNotNull { index -> array.getMap(index) } - val nonNull = schemas.filterNot { readTypeNames(it) == listOf("null") } - if (nonNull.size < schemas.size) nullable = true - nonNull.map { fromReadableMap(it) } - } - - // A nullable value with a single option is that option, marked nullable - if (type == null && anyOf?.size == 1) { - return anyOf.first().copy(nullable = if (nullable) true else anyOf.first().nullable) - } - - return Schema( - type = type, - properties = properties, - items = map.getMap("items")?.let { fromReadableMap(it) }, - required = required, - description = map.getString("description"), - enum = enumValues, - format = map.getString("format"), - nullable = if (nullable) true else null, - anyOf = anyOf?.takeIf { it.isNotEmpty() }, - title = map.getString("title"), - pattern = map.getString("pattern"), - minimum = map.getDoubleOrNull("minimum"), - maximum = map.getDoubleOrNull("maximum"), - minLength = map.getDoubleOrNull("minLength")?.toLong(), - maxLength = map.getDoubleOrNull("maxLength")?.toLong(), - minItems = map.getDoubleOrNull("minItems")?.toLong(), - maxItems = map.getDoubleOrNull("maxItems")?.toLong(), - minProperties = map.getDoubleOrNull("minProperties")?.toLong(), - maxProperties = map.getDoubleOrNull("maxProperties")?.toLong(), - ) - } - - private fun readTypeNames(map: ReadableMap): List { - if (!map.hasKey("type")) return emptyList() - return when (map.getType("type")) { - ReadableType.String -> listOfNotNull(map.getString("type")) - ReadableType.Array -> map.getArray("type")?.strings() ?: emptyList() - else -> emptyList() - } - } - - private fun ReadableArray.strings(): List = - (0 until size()).mapNotNull { index -> getString(index) } - - private fun ReadableMap.getDoubleOrNull(key: String): Double? = - if (hasKey(key) && getType(key) == ReadableType.Number) getDouble(key) else null - - private fun ReadableMap.getBooleanOrNull(key: String): Boolean? = - if (hasKey(key) && getType(key) == ReadableType.Boolean) getBoolean(key) else null - - private fun parseType(type: String?): Type? { - return when (type) { - "string" -> Type.STRING - "number" -> Type.NUMBER - "integer" -> Type.INTEGER - "boolean" -> Type.BOOLEAN - "array" -> Type.ARRAY - "object" -> Type.OBJECT - else -> null - } - } -} diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkStreamToolCalls.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkStreamToolCalls.kt deleted file mode 100644 index d5623ce5..00000000 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkStreamToolCalls.kt +++ /dev/null @@ -1,119 +0,0 @@ -package com.callstack.ai.adk - -import com.facebook.react.bridge.Arguments -import com.facebook.react.bridge.WritableMap -import com.google.adk.kt.events.Event - -class AdkStreamToolCallEmitter( - private val streamId: String, - private val emit: (WritableMap) -> Unit, -) { - private class ActiveCall( - var toolName: String, - var started: Boolean = false, - var completed: Boolean = false, - val inputBuilder: StringBuilder = StringBuilder(), - ) - - private val activeCalls = mutableMapOf() - - fun handleEvent(event: Event) { - for (functionCall in event.functionCalls()) { - val toolCallId = functionCall.id ?: "${functionCall.name}-${activeCalls.size}" - val state = activeCalls.getOrPut(toolCallId) { - ActiveCall(toolName = functionCall.name) - } - - if (functionCall.name.isNotEmpty()) { - state.toolName = functionCall.name - } - - if (!state.started && state.toolName.isNotEmpty()) { - emit( - Arguments.createMap().apply { - putString("streamId", streamId) - putString("phase", "start") - putString("toolCallId", toolCallId) - putString("toolName", state.toolName) - }, - ) - state.started = true - } - - if (!functionCall.partialArgs.isNullOrEmpty()) { - for (partialArg in functionCall.partialArgs) { - val delta = - partialArg.stringValue - ?: partialArg.numberValue?.toString() - ?: partialArg.boolValue?.toString() - ?: continue - - emit( - Arguments.createMap().apply { - putString("streamId", streamId) - putString("phase", "delta") - putString("toolCallId", toolCallId) - putString("inputDelta", delta) - }, - ) - state.inputBuilder.append(delta) - } - } - - // A complete event carries the final arguments, which are empty for tools without parameters - if ((functionCall.args.isNotEmpty() || !event.partial) && state.started && !state.completed) { - val input = - if (functionCall.args.isEmpty() && state.inputBuilder.isNotEmpty()) { - state.inputBuilder.toString() - } else { - AdkJson.encode(functionCall.args) - } - if (state.inputBuilder.isEmpty()) { - emit( - Arguments.createMap().apply { - putString("streamId", streamId) - putString("phase", "delta") - putString("toolCallId", toolCallId) - putString("inputDelta", input) - }, - ) - } - - emitEnd(toolCallId, state.toolName, input) - state.completed = true - } else if (functionCall.willContinue == false && state.started && !state.completed) { - val input = state.inputBuilder.toString().ifEmpty { "{}" } - emitEnd(toolCallId, state.toolName, input) - state.completed = true - } - } - } - - /** Emits the result of each tool call that ADK ran in this event. */ - fun handleResults(event: Event) { - for (functionResponse in event.functionResponses()) { - val toolCallId = functionResponse.id ?: continue - emit( - Arguments.createMap().apply { - putString("streamId", streamId) - putString("phase", "result") - putString("toolCallId", toolCallId) - putString("toolName", functionResponse.name) - putString("output", AdkJson.encode(functionResponse.response)) - }, - ) - } - } - - private fun emitEnd(toolCallId: String, toolName: String, input: String) { - emit( - Arguments.createMap().apply { - putString("streamId", streamId) - putString("phase", "end") - putString("toolCallId", toolCallId) - putString("toolName", toolName) - putString("input", input) - }, - ) - } -} diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkToolBridge.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkToolBridge.kt deleted file mode 100644 index 734f0c81..00000000 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkToolBridge.kt +++ /dev/null @@ -1,39 +0,0 @@ -package com.callstack.ai.adk - -import kotlinx.coroutines.CompletableDeferred -import java.util.concurrent.ConcurrentHashMap - -/** Waits for tool results that JavaScript submits, grouped by run. */ -object AdkToolBridge { - private val pendingResults = - ConcurrentHashMap>>() - - /** Registers the call before [request] asks JS to run it, then waits for the result. */ - suspend fun call(runId: String, toolCallId: String, request: () -> Unit): String { - val calls = pendingResults.computeIfAbsent(runId) { ConcurrentHashMap() } - val deferred = CompletableDeferred() - calls[toolCallId] = deferred - try { - request() - return deferred.await() - } finally { - calls.remove(toolCallId, deferred) - // Drop the run once it has no pending calls - pendingResults.computeIfPresent(runId) { _, runCalls -> runCalls.takeIf { it.isNotEmpty() } } - } - } - - fun submitResult(runId: String, toolCallId: String, result: String) { - pendingResults[runId]?.get(toolCallId)?.complete(result) - } - - fun cancel(runId: String) { - pendingResults.remove(runId)?.values?.forEach { it.complete(CANCELLED_RESULT) } - } - - fun cancelAll() { - pendingResults.keys.toList().forEach(::cancel) - } - - private const val CANCELLED_RESULT = "{\"error\":\"Tool call cancelled\"}" -} diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkUsage.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkUsage.kt index 4494e4c0..8acc336f 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkUsage.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/AdkUsage.kt @@ -18,10 +18,7 @@ object AdkUsage { } } - /** - * Usage of a whole run. A tool loop makes one model call per step, and each complete event - * carries the usage of its call, so the run's usage is their sum. - */ + /** Usage of a whole run: the sum over its complete events, which carry their call's usage. */ fun fromEvents(events: List): UsageMetadata? = events.filterNot { it.partial }.fold(null as UsageMetadata?) { total, event -> add(total, event) } ?: events.mapNotNull { it.usageMetadata }.lastOrNull() diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt index abfae1e2..0348a547 100644 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt +++ b/packages/adk/android/src/main/java/com/callstack/ai/adk/NativeAdkEngineModule.kt @@ -26,16 +26,6 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO) private val runner = AdkAgentRunner( context = reactContext, - onToolCall = { runId, toolCallId, toolName, arguments -> - emitOnToolCall( - Arguments.createMap().apply { - putString("runId", runId) - putString("toolCallId", toolCallId) - putString("toolName", toolName) - putString("arguments", arguments) - }, - ) - }, onDownloadProgress = { phase, bytesDownloaded, bytesToDownload -> emitOnNanoDownloadProgress( Arguments.createMap().apply { @@ -54,10 +44,10 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : reject(AdkErrors.codeFor(error), error.message ?: "Unknown ADK error", error) } - override fun getModelInfo(modelType: String, nano: ReadableMap?, promise: Promise) { + override fun getModelInfo(nano: ReadableMap?, promise: Promise) { scope.launch { try { - val info = runner.getModelInfo(modelType, NanoConfig.from(nano)) + val info = runner.getModelInfo(NanoConfig.from(nano)) promise.resolve( Arguments.createMap().apply { putString("availability", info.availability) @@ -97,45 +87,16 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : messages: ReadableArray, config: ReadableMap, options: ReadableMap?, - tools: ReadableArray?, promise: Promise, ) { // Started after it is tracked, so a run that ends at once is still removed val job = scope.launch(start = CoroutineStart.LAZY) { try { - val result = runner.generateText(messages, config, options, tools, runId) + val result = runner.generateText(messages, config, options) val response = Arguments.createMap().apply { putString("role", "assistant") putString("content", result.content) result.reasoning?.let { putString("reasoning", it) } - putArray( - "toolCalls", - Arguments.createArray().apply { - result.toolCalls.forEach { call -> - pushMap( - Arguments.createMap().apply { - putString("toolCallId", call.toolCallId) - putString("toolName", call.toolName) - putString("input", call.input) - }, - ) - } - }, - ) - putArray( - "toolResults", - Arguments.createArray().apply { - result.toolResults.forEach { toolResult -> - pushMap( - Arguments.createMap().apply { - putString("toolCallId", toolResult.toolCallId) - putString("toolName", toolResult.toolName) - putString("output", toolResult.output) - }, - ) - } - }, - ) result.finishReason?.let { putString("finishReason", it) } AdkUsage.toWritableMap(result.usage)?.let { putMap("usage", it) } } @@ -144,7 +105,6 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : promise.rejectWithCode(error) } finally { activeRuns.remove(runId) - AdkToolBridge.cancel(runId) } } activeRuns[runId] = job @@ -156,7 +116,6 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : messages: ReadableArray, config: ReadableMap, options: ReadableMap?, - tools: ReadableArray?, promise: Promise, ) { if (activeRuns.containsKey(streamId)) { @@ -176,17 +135,12 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : var emittedText = "" var currentTurnReasoning = "" var emittedReasoning = "" - val toolCallEmitter = AdkStreamToolCallEmitter(streamId) { args -> - emitOnStreamToolCall(args) - } - runner.streamText(messages, config, options, tools, streamId).collect { event -> + runner.streamText(messages, config, options).collect { event -> if (!isActive) return@collect totalUsage = AdkUsage.add(totalUsage, event) if (event.partial) event.usageMetadata?.let { partialUsage = it } - toolCallEmitter.handleEvent(event) - toolCallEmitter.handleResults(event) val reasoning = event.textParts(thoughts = true) if (reasoning.isNotEmpty()) { @@ -207,13 +161,7 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : if (text.startsWith(currentTurnText)) text else currentTurnText + text } - if (!event.partial && event.functionCalls().isNotEmpty()) { - // A tool call ends the turn, and the next turn starts with new text - currentTurnText = "" - emittedText = "" - currentTurnReasoning = "" - emittedReasoning = "" - } else if (currentTurnText.length > emittedText.length && + if (currentTurnText.length > emittedText.length && currentTurnText.startsWith(emittedText) ) { emitDelta(streamId, currentTurnText.substring(emittedText.length), "text") @@ -233,7 +181,6 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : emitOnStreamError(errorArgs) } finally { activeRuns.remove(streamId) - AdkToolBridge.cancel(streamId) } } @@ -266,18 +213,12 @@ class NativeAdkEngineModule(reactContext: ReactApplicationContext) : override fun cancelStream(streamId: String, promise: Promise) { activeRuns.remove(streamId)?.cancel() - AdkToolBridge.cancel(streamId) promise.resolve(null) } - override fun submitToolResult(runId: String, toolCallId: String, result: String) { - AdkToolBridge.submitResult(runId, toolCallId, result) - } - override fun invalidate() { activeRuns.values.forEach { it.cancel() } activeRuns.clear() - AdkToolBridge.cancelAll() scope.cancel() super.invalidate() } diff --git a/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt b/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt deleted file mode 100644 index 0b0d3b63..00000000 --- a/packages/adk/android/src/main/java/com/callstack/ai/adk/ReactNativeFunctionTool.kt +++ /dev/null @@ -1,41 +0,0 @@ -package com.callstack.ai.adk - -import com.google.adk.kt.tools.BaseTool -import com.google.adk.kt.tools.FunctionTool -import com.google.adk.kt.tools.ToolContext -import com.google.adk.kt.types.FunctionDeclaration -import com.google.adk.kt.types.Schema -import com.google.adk.kt.types.Type -import java.util.UUID - -/** An ADK tool whose `execute` runs in JavaScript. */ -class ReactNativeFunctionTool( - name: String, - description: String, - private val parameterSchema: Schema?, - private val runId: String, - private val onToolCall: ( - runId: String, - toolCallId: String, - toolName: String, - arguments: String, - ) -> Unit, -) : FunctionTool(name = name, description = description) { - - override fun declaration(): FunctionDeclaration = - FunctionDeclaration( - name = name, - description = description, - parameters = parameterSchema ?: Schema(type = Type.OBJECT), - ) - - override suspend fun execute(context: ToolContext, args: Map): Any { - // Use ADK's id so JS sees the same id as the reported tool call - val toolCallId = context.functionCallId ?: UUID.randomUUID().toString() - val result = AdkToolBridge.call(runId, toolCallId) { - onToolCall(runId, toolCallId, name, AdkJson.encode(args)) - } - // ADK wraps values that are not maps under `result` - return AdkJson.decodeResult(result) ?: mapOf(BaseTool.RESULT_KEY to null) - } -} diff --git a/packages/adk/src/NativeAdkEngine.ts b/packages/adk/src/NativeAdkEngine.ts index ba712924..62249194 100644 --- a/packages/adk/src/NativeAdkEngine.ts +++ b/packages/adk/src/NativeAdkEngine.ts @@ -15,8 +15,6 @@ export interface AdkMessage { parts?: AdkMessagePart[] } -export type AdkModelType = 'gemini' | 'genai-nano' - export interface AdkNanoModelConfig { /** `stable` (default) or `preview`, which needs the AICore developer preview */ releaseStage?: 'stable' | 'preview' @@ -28,36 +26,13 @@ export interface AdkAgentConfig { name: string description?: string instruction?: string - model: { - type: AdkModelType - name: string - apiKey?: string - nano?: AdkNanoModelConfig - } -} - -export interface AdkTool { - name: string - description: string - inputSchema?: CodegenTypes.UnsafeObject -} - -export interface AdkResponseFormat { - type: 'json' - mimeType?: string - schema?: CodegenTypes.UnsafeObject + nano?: AdkNanoModelConfig } export interface AdkGenerationOptions { temperature?: number maxTokens?: number - topP?: number topK?: number - seed?: number - stopSequences?: string[] - presencePenalty?: number - frequencyPenalty?: number - responseFormat?: AdkResponseFormat /** Thinking on/off with an optional budget. Gemini Nano only supports on/off */ thinking?: { includeThoughts: boolean @@ -73,24 +48,10 @@ export interface AdkUsageMetadata { cachedContentTokenCount?: number } -export interface AdkToolCallRecord { - toolCallId: string - toolName: string - input: string -} - -export interface AdkToolResultRecord { - toolCallId: string - toolName: string - output: string -} - export interface AdkGeneratedMessage { role: AdkMessageRole content: string reasoning?: string - toolCalls?: AdkToolCallRecord[] - toolResults?: AdkToolResultRecord[] finishReason?: string usage?: AdkUsageMetadata } @@ -120,24 +81,6 @@ export interface StreamErrorEvent { code?: string } -export interface StreamToolCallEvent { - streamId: string - phase: 'start' | 'delta' | 'end' | 'result' - toolCallId: string - toolName?: string - inputDelta?: string - input?: string - output?: string -} - -export interface ToolCallEvent { - /** The `generateText` or `streamText` run that called the tool */ - runId: string - toolCallId: string - toolName: string - arguments: string -} - export interface NanoDownloadProgressEvent { /** `started`, `progress` or `completed` */ phase: string @@ -146,10 +89,7 @@ export interface NanoDownloadProgressEvent { } export interface Spec extends TurboModule { - getModelInfo( - modelType: AdkModelType, - nano?: AdkNanoModelConfig - ): Promise + getModelInfo(nano?: AdkNanoModelConfig): Promise prepareNano(nano?: AdkNanoModelConfig): Promise countTokens(text: string, nano?: AdkNanoModelConfig): Promise @@ -157,28 +97,22 @@ export interface Spec extends TurboModule { runId: string, messages: AdkMessage[], config: AdkAgentConfig, - options?: AdkGenerationOptions, - tools?: AdkTool[] + options?: AdkGenerationOptions ): Promise streamText( streamId: string, messages: AdkMessage[], config: AdkAgentConfig, - options?: AdkGenerationOptions, - tools?: AdkTool[] + options?: AdkGenerationOptions ): Promise /** Cancels a `streamText` or `generateText` run by its id */ cancelStream(streamId: string): Promise - /** `result` is JSON */ - submitToolResult(runId: string, toolCallId: string, result: string): void onStreamUpdate: CodegenTypes.EventEmitter onStreamComplete: CodegenTypes.EventEmitter onStreamError: CodegenTypes.EventEmitter - onStreamToolCall: CodegenTypes.EventEmitter - onToolCall: CodegenTypes.EventEmitter onNanoDownloadProgress: CodegenTypes.EventEmitter } diff --git a/packages/adk/src/__tests__/ai-sdk.test.ts b/packages/adk/src/__tests__/ai-sdk.test.ts index 55282d3b..761031c6 100644 --- a/packages/adk/src/__tests__/ai-sdk.test.ts +++ b/packages/adk/src/__tests__/ai-sdk.test.ts @@ -21,9 +21,7 @@ function createEmitter() { const onStreamUpdate = createEmitter() const onStreamComplete = createEmitter() const onStreamError = createEmitter() -const onStreamToolCall = createEmitter() const onNanoDownloadProgress = createEmitter() -const onToolCall = createEmitter() let generateTextResult: Record = { content: 'ok', @@ -35,8 +33,7 @@ const generateText = mock( _runId: string, _messages: unknown[], _config: unknown, - _options: unknown, - _tools: unknown + _options: unknown ): Promise> => generateTextResult ) const streamText = mock( @@ -44,16 +41,12 @@ const streamText = mock( _streamId: string, _messages: unknown[], _config: unknown, - _options: unknown, - _tools: unknown + _options: unknown ) => {} ) const prepareNano = mock(async (_nano?: unknown) => {}) const cancelStream = mock(async (_id: string) => {}) -const submitToolResult = mock( - (_runId: string, _toolCallId: string, _result: string) => {} -) -const getModelInfo = mock(async (_modelType: string, _nano?: unknown) => ({ +const getModelInfo = mock(async (_nano?: unknown) => ({ availability: 'downloadable', })) @@ -66,10 +59,7 @@ mock.module('react-native', () => ({ prepareNano, cancelStream, getModelInfo, - onToolCall, - submitToolResult, onStreamUpdate, - onStreamToolCall, onStreamComplete, onStreamError, onNanoDownloadProgress, @@ -79,7 +69,6 @@ mock.module('react-native', () => ({ const { createAdkProvider } = await import('../ai-sdk') -const gemini = createAdkProvider({ modelType: 'gemini' })() const nano = createAdkProvider()() // PNG signature followed by padding bytes @@ -112,7 +101,7 @@ async function readAll(stream: ReadableStream) { async function runStream( options: LanguageModelV4CallOptions, play: (streamId: string) => void, - model = gemini + model = nano ) { streamText.mockImplementationOnce(async (streamId: string) => { queueMicrotask(() => play(streamId)) @@ -126,56 +115,34 @@ beforeEach(() => { streamText.mockClear() prepareNano.mockClear() cancelStream.mockClear() - submitToolResult.mockClear() + getModelInfo.mockClear() generateTextResult = { content: 'ok', finishReason: 'STOP' } }) -describe('model resolution', () => { - test('defaults to on-device Gemini Nano', () => { +describe('provider', () => { + test('creates Gemini Nano models', () => { expect(nano.modelId).toBe('gemini-nano') + expect(nano.provider).toBe('adk') }) - test('defaults cloud Gemini to gemini-3.8-flash', () => { - expect(gemini.modelId).toBe('gemini-3.8-flash') - }) - - test('takes the model id as a model option', () => { - const provider = createAdkProvider({ model: 'gemini-3.5-flash-lite' }) - - expect(provider().modelId).toBe('gemini-3.5-flash-lite') - expect(provider({ modelName: 'gemini-nano' }).modelId).toBe('gemini-nano') - }) - - test('infers cloud Gemini from a model name', async () => { - const model = createAdkProvider()('gemini-4-argon') - await model.doGenerate(createCallOptions()) - - expect(lastGenerateCall()[2]).toMatchObject({ - model: { type: 'gemini', name: 'gemini-4-argon' }, - }) - }) - - test('per-model options override provider defaults', () => { - const provider = createAdkProvider({ instruction: 'Be brief.' }) - expect(provider({ model: 'gemini-4-argon' }).modelId).toBe('gemini-4-argon') - expect(provider.languageModel().modelId).toBe('gemini-nano') - }) + test('reports Gemini Nano availability', async () => { + getModelInfo.mockImplementationOnce(async () => ({ + availability: 'available', + baseModelName: 'nano-v3', + contextSize: 4096, + })) - test('reports model availability', async () => { expect(await createAdkProvider().getModelInfo()).toEqual({ - model: 'gemini-nano', - modelType: 'genai-nano', - availability: 'downloadable', - supportsTokenCounting: true, - baseModelName: undefined, - contextSize: undefined, + availability: 'available', + baseModelName: 'nano-v3', + contextSize: 4096, }) }) - test('reports availability for another model', async () => { - await createAdkProvider().getModelInfo({ model: 'gemini-3.8-flash' }) + test('passes the model selection to the availability check', async () => { + await createAdkProvider({ nano: { preference: 'fast' } }).getModelInfo() - expect(getModelInfo.mock.calls.at(-1)![0]).toBe('gemini') + expect(getModelInfo.mock.calls.at(-1)![0]).toEqual({ preference: 'fast' }) }) test('derives isAvailable from the model info', async () => { @@ -191,10 +158,7 @@ describe('model resolution', () => { describe('prompt conversion', () => { test('moves system messages into the agent instruction', async () => { - const model = createAdkProvider({ - modelType: 'gemini', - instruction: 'Be brief.', - })() + const model = createAdkProvider({ instruction: 'Be brief.' })() await model.doGenerate( createCallOptions({ prompt: [ @@ -212,7 +176,7 @@ describe('prompt conversion', () => { }) test('resolves top-level file media types to a full mime type', async () => { - await gemini.doGenerate( + await nano.doGenerate( createCallOptions({ prompt: [ { @@ -246,7 +210,7 @@ describe('prompt conversion', () => { }) test('passes local image URLs to native code', async () => { - await gemini.doGenerate( + await nano.doGenerate( createCallOptions({ prompt: [ { @@ -273,8 +237,8 @@ describe('prompt conversion', () => { ]) }) - test('replays earlier tool steps as assistant text', async () => { - await gemini.doGenerate( + test('drops tool steps from the history with a warning', async () => { + const result = await nano.doGenerate( createCallOptions({ prompt: [ { role: 'user', content: [{ type: 'text', text: 'time?' }] }, @@ -285,13 +249,7 @@ describe('prompt conversion', () => { type: 'tool-call', toolCallId: '1', toolName: 'getTime', - input: { city: 'Warsaw' }, - }, - { - type: 'tool-result', - toolCallId: '1', - toolName: 'getTime', - output: { type: 'json', value: { time: '10:00' } }, + input: {}, }, { type: 'text', text: 'It is 10:00.' }, ], @@ -303,137 +261,17 @@ describe('prompt conversion', () => { expect(lastGenerateCall()[1][1]).toEqual({ role: 'assistant', - content: - '[Tool call: getTime({"city":"Warsaw"})]\n[Tool result for getTime: {"time":"10:00"}]\nIt is 10:00.', + content: 'It is 10:00.', }) - }) -}) - -const weatherTool = { - type: 'function' as const, - name: 'getWeather', - inputSchema: { - type: 'object' as const, - properties: { city: { type: 'string' } }, - required: ['city'], - }, -} - -describe('tool choice', () => { - test('sends no tools for toolChoice none', async () => { - await gemini.doGenerate( - createCallOptions({ tools: [weatherTool], toolChoice: { type: 'none' } }) - ) - - expect(lastGenerateCall()[4]).toEqual([]) - }) - - test('warns that required tool choice is unsupported', async () => { - const result = await gemini.doGenerate( - createCallOptions({ toolChoice: { type: 'required' } }) - ) - - expect(result.warnings).toEqual([ - { - type: 'unsupported', - feature: 'toolChoice', - details: - 'ADK runs tools natively and cannot be required to call a tool.', - }, - ]) - }) - - test('limits tools to the chosen tool', async () => { - await gemini.doGenerate( - createCallOptions({ - tools: [weatherTool, { ...weatherTool, name: 'getTime' }], - toolChoice: { type: 'tool', toolName: 'getTime' }, - }) - ) - - expect( - (lastGenerateCall()[4] as { name: string }[]).map((tool) => tool.name) - ).toEqual(['getTime']) - }) - - test('warns when a tool has no registered executor', async () => { - const result = await gemini.doGenerate( - createCallOptions({ tools: [weatherTool] }) + expect(result.warnings).toContainEqual( + expect.objectContaining({ feature: 'assistant tool-call parts' }) ) - - expect(result.warnings).toContainEqual({ - type: 'other', - message: - 'Tool "getWeather" has no executor. Pass it to createAdkProvider via availableTools so ADK can run it.', - }) - }) -}) - -describe('tool execution', () => { - // Calls the tool from native code during the run, then waits for its result - async function callTool( - execute: (input: unknown, options: { toolCallId: string }) => unknown, - eventRunId = (runId: string) => runId - ) { - const model = createAdkProvider({ - modelType: 'gemini', - availableTools: { - getWeather: { inputSchema: weatherTool.inputSchema, execute }, - } as never, - })() - generateText.mockImplementationOnce(async (runId: string) => { - onToolCall.emit({ - runId: eventRunId(runId), - toolCallId: 'adk-call-1', - toolName: 'getWeather', - arguments: '{"city":"Oslo"}', - }) - await new Promise((resolve) => setTimeout(resolve, 0)) - return generateTextResult - }) - - await model.doGenerate(createCallOptions({ tools: [weatherTool] })) - return submitToolResult.mock.calls.at(-1) - } - - test('runs the tool with the ADK tool call id', async () => { - const execute = mock(async () => ({ sky: 'clear' })) - const [, toolCallId, result] = (await callTool(execute))! - - expect(execute.mock.calls[0]).toMatchObject([ - { city: 'Oslo' }, - { toolCallId: 'adk-call-1' }, - ]) - expect(toolCallId).toBe('adk-call-1') - expect(result).toBe('{"sky":"clear"}') - }) - - test('sends string results as JSON', async () => { - const [, , result] = (await callTool(async () => '42'))! - - expect(result).toBe('"42"') - }) - - test('sends tool errors back to the model', async () => { - const [, , result] = (await callTool(async () => { - throw new Error('offline') - }))! - - expect(result).toBe('{"error":"offline"}') - }) - - test('ignores tool calls from other runs', async () => { - const execute = mock(async () => 'ok') - await callTool(execute, () => 'other') - - expect(execute).not.toHaveBeenCalled() - expect(submitToolResult).not.toHaveBeenCalled() }) }) describe('generation options', () => { test('maps reasoning levels to a thinking budget', async () => { - await gemini.doGenerate(createCallOptions({ reasoning: 'high' })) + await nano.doGenerate(createCallOptions({ reasoning: 'high' })) expect(lastGenerateCall()[3]).toMatchObject({ thinking: { includeThoughts: true, budget: 24576 }, @@ -441,7 +279,7 @@ describe('generation options', () => { }) test('disables thinking for reasoning none', async () => { - await gemini.doGenerate(createCallOptions({ reasoning: 'none' })) + await nano.doGenerate(createCallOptions({ reasoning: 'none' })) expect(lastGenerateCall()[3]).toMatchObject({ thinking: { includeThoughts: false, budget: 0 }, @@ -449,38 +287,41 @@ describe('generation options', () => { }) test('leaves thinking to the model by default', async () => { - await gemini.doGenerate(createCallOptions()) + await nano.doGenerate(createCallOptions()) expect((lastGenerateCall()[3] as { thinking?: unknown }).thinking).toBe( undefined ) }) - test('passes a response schema to cloud Gemini', async () => { - const schema = { type: 'object', properties: { name: { type: 'string' } } } - await gemini.doGenerate( - createCallOptions({ responseFormat: { type: 'json', schema } }) + test('passes the settings Gemini Nano takes', async () => { + await nano.doGenerate( + createCallOptions({ temperature: 0.2, maxOutputTokens: 50, topK: 3 }) ) - expect(lastGenerateCall()[3]).toMatchObject({ - responseFormat: { type: 'json', schema }, + expect(lastGenerateCall()[3]).toEqual({ + temperature: 0.2, + maxTokens: 50, + topK: 3, + thinking: undefined, }) }) - test('warns that Gemini Nano has no JSON mode', async () => { - const schema = { type: 'object', properties: { name: { type: 'string' } } } + test('warns about settings Gemini Nano ignores', async () => { + const result = await nano.doGenerate( + createCallOptions({ topP: 0.5, seed: 1, stopSequences: ['END'] }) + ) + + expect( + result.warnings.map((warning) => 'feature' in warning && warning.feature) + ).toEqual(['topP', 'seed', 'stopSequences']) + }) + + test('warns that JSON output is unsupported', async () => { const result = await nano.doGenerate( - createCallOptions({ responseFormat: { type: 'json', schema } }) + createCallOptions({ responseFormat: { type: 'json' } }) ) - const [, , config, options] = lastGenerateCall() as [ - string, - unknown, - { instruction?: string }, - { responseFormat?: unknown }, - ] - expect(config.instruction).toBe(undefined) - expect(options.responseFormat).toBe(undefined) expect(result.warnings).toContainEqual( expect.objectContaining({ type: 'unsupported', @@ -489,28 +330,31 @@ describe('generation options', () => { ) }) - test('warns about settings Gemini Nano ignores', async () => { + test('warns that tools are unsupported', async () => { const result = await nano.doGenerate( - createCallOptions({ topP: 0.5, seed: 1, stopSequences: ['END'] }) + createCallOptions({ + tools: [ + { + type: 'function', + name: 'getWeather', + inputSchema: { type: 'object', properties: {} }, + }, + ], + }) ) - expect( - result.warnings.map((warning) => 'feature' in warning && warning.feature) - ).toEqual(['topP', 'seed', 'stopSequences']) + expect(lastGenerateCall()).toHaveLength(4) + expect(result.warnings).toContainEqual( + expect.objectContaining({ type: 'unsupported', feature: 'tools' }) + ) }) }) describe('doGenerate results', () => { - test('returns reasoning, provider-executed tool steps and text', async () => { + test('returns reasoning, text and usage', async () => { generateTextResult = { content: 'It is sunny.', reasoning: 'Check the weather.', - toolCalls: [ - { toolCallId: '1', toolName: 'getWeather', input: '{"city":"Oslo"}' }, - ], - toolResults: [ - { toolCallId: '1', toolName: 'getWeather', output: '{"sky":"clear"}' }, - ], finishReason: 'STOP', usage: { promptTokenCount: 10, @@ -520,23 +364,10 @@ describe('doGenerate results', () => { }, } - const result = await gemini.doGenerate(createCallOptions()) + const result = await nano.doGenerate(createCallOptions()) expect(result.content).toEqual([ { type: 'reasoning', text: 'Check the weather.' }, - { - type: 'tool-call', - toolCallId: '1', - toolName: 'getWeather', - input: '{"city":"Oslo"}', - providerExecuted: true, - }, - { - type: 'tool-result', - toolCallId: '1', - toolName: 'getWeather', - result: { sky: 'clear' }, - }, { type: 'text', text: 'It is sunny.' }, ]) expect(result.usage.inputTokens).toEqual({ @@ -555,7 +386,7 @@ describe('doGenerate results', () => { test('maps safety finish reasons to content-filter', async () => { generateTextResult = { content: '', finishReason: 'SAFETY' } - const result = await gemini.doGenerate(createCallOptions()) + const result = await nano.doGenerate(createCallOptions()) expect(result.finishReason).toEqual({ unified: 'content-filter', @@ -568,7 +399,7 @@ describe('doGenerate results', () => { throw Object.assign(new Error('busy'), { code: 'RATE_LIMITED' }) }) - expect(gemini.doGenerate(createCallOptions())).rejects.toMatchObject({ + expect(nano.doGenerate(createCallOptions())).rejects.toMatchObject({ message: 'busy', code: 'RATE_LIMITED', }) @@ -581,7 +412,7 @@ describe('doGenerate results', () => { throw new Error('cancelled') }) - const error = await gemini + const error = await nano .doGenerate(createCallOptions({ abortSignal: controller.signal })) .catch((caught: unknown) => caught) @@ -591,29 +422,9 @@ describe('doGenerate results', () => { }) describe('doStream', () => { - test('streams reasoning, tool steps and text', async () => { + test('streams reasoning and text', async () => { const parts = await runStream(createCallOptions(), (streamId) => { onStreamUpdate.emit({ streamId, delta: 'Thinking', kind: 'reasoning' }) - onStreamToolCall.emit({ - streamId, - phase: 'start', - toolCallId: '1', - toolName: 'getWeather', - }) - onStreamToolCall.emit({ - streamId, - phase: 'end', - toolCallId: '1', - toolName: 'getWeather', - input: '{}', - }) - onStreamToolCall.emit({ - streamId, - phase: 'result', - toolCallId: '1', - toolName: 'getWeather', - output: '{"sky":"clear"}', - }) onStreamUpdate.emit({ streamId, delta: 'Sunny', kind: 'text' }) onStreamComplete.emit({ streamId, finishReason: 'STOP' }) }) @@ -623,41 +434,11 @@ describe('doStream', () => { 'reasoning-start', 'reasoning-delta', 'reasoning-end', - 'tool-input-start', - 'tool-input-end', - 'tool-call', - 'tool-result', 'text-start', 'text-delta', 'text-end', 'finish', ]) - expect(parts).toContainEqual({ - type: 'tool-result', - toolCallId: '1', - toolName: 'getWeather', - result: { sky: 'clear' }, - }) - }) - - test('warns that Gemini Nano has no tool calling', async () => { - const result = await nano.doGenerate( - createCallOptions({ - tools: [ - { - type: 'function', - name: 'getWeather', - inputSchema: { type: 'object', properties: {} }, - }, - ], - }) - ) - - const [, , , , tools] = lastGenerateCall() as unknown[] - expect(tools).toEqual([]) - expect(result.warnings).toContainEqual( - expect.objectContaining({ type: 'unsupported', feature: 'tools' }) - ) }) test('surfaces native stream errors with their code', async () => { @@ -697,18 +478,6 @@ describe('Gemini Nano preparation', () => { ]) }) - test('keeps the deprecated prepareNano', async () => { - await createAdkProvider({ model: 'gemini-3.8-flash' }).prepareNano() - - expect(prepareNano).toHaveBeenCalledTimes(1) - }) - - test('does not prepare cloud models', async () => { - await gemini.prepare() - - expect(prepareNano).not.toHaveBeenCalled() - }) - test('passes the model selection to native code', async () => { const provider = createAdkProvider({ nano: { releaseStage: 'preview' } }) await provider().prepare() diff --git a/packages/adk/src/ai-sdk.ts b/packages/adk/src/ai-sdk.ts index 1bbf3e13..49c5a928 100644 --- a/packages/adk/src/ai-sdk.ts +++ b/packages/adk/src/ai-sdk.ts @@ -1,25 +1,15 @@ import type { - JSONValue, LanguageModelV4, LanguageModelV4CallOptions, LanguageModelV4Content, LanguageModelV4FilePart, LanguageModelV4FinishReason, - LanguageModelV4FunctionTool, LanguageModelV4Prompt, - LanguageModelV4ProviderTool, LanguageModelV4StreamPart, LanguageModelV4Usage, SharedV4Warning, } from '@ai-sdk/provider' -import { - generateId, - jsonSchema, - parseJSON, - resolveFullMediaType, - type Tool as FullToolDefinition, - type ToolExecutionOptions, -} from '@ai-sdk/provider-utils' +import { generateId, resolveFullMediaType } from '@ai-sdk/provider-utils' import { Platform } from 'react-native' import { AdkErrorCodes, createAdkError, toAdkError } from './errors' @@ -28,49 +18,27 @@ import { type AdkGenerationOptions, type AdkMessage, type AdkMessagePart, - type AdkModelType, type AdkNanoModelConfig, - type AdkTool, type AdkUsageMetadata, getNativeAdkEngine, type NanoDownloadProgressEvent, - type StreamToolCallEvent, - type ToolCallEvent, } from './NativeAdkEngine' -const DEFAULT_NANO_MODEL = 'gemini-nano' -const DEFAULT_GEMINI_MODEL = 'gemini-3.8-flash' - -export type AdkToolDefinitionSet = Record - -/** `gemini-nano` runs on device, any other name is a cloud Gemini model */ -export type AdkLanguageModelId = 'gemini-nano' | (string & {}) +const MODEL_ID = 'gemini-nano' export interface AdkLanguageModelOptions { - /** `gemini-nano` (default) runs on device, any other id is a cloud Gemini model */ - model?: AdkLanguageModelId - /** @deprecated Use `model`. Without a model, `gemini` uses `gemini-3.8-flash` */ - modelType?: AdkModelType - /** @deprecated Use `model` */ - modelName?: AdkLanguageModelId /** ADK agent name */ name?: string /** ADK agent description */ description?: string /** System instruction for the agent */ instruction?: string - /** Gemini API key, required for `gemini` */ - apiKey?: string - /** Tools whose `execute` handlers ADK can call */ - availableTools?: AdkToolDefinitionSet /** Gemini Nano model selection */ nano?: AdkNanoModelConfig } /** Per-call options passed as `providerOptions.adk` */ export interface AdkProviderOptions { - /** Thinking token budget for cloud Gemini. `0` disables thinking */ - thinkingBudget?: number /** Whether the model's thoughts come back as reasoning parts */ includeThoughts?: boolean } @@ -83,11 +51,7 @@ export type AdkModelAvailability = | 'unknown' export interface AdkModelInfo { - model: AdkLanguageModelId - modelType: AdkModelType availability: AdkModelAvailability - /** Whether `countTokens` works, which only Gemini Nano supports */ - supportsTokenCounting: boolean /** Name of the Gemini Nano base model, when ML Kit reports it */ baseModelName?: string /** Gemini Nano input token limit, when ML Kit reports it */ @@ -105,67 +69,22 @@ export interface AdkPrepareOptions { } export interface AdkLanguageModel extends LanguageModelV4 { - /** Downloads and initializes Gemini Nano, reporting progress. No-op for cloud models */ + /** Downloads Gemini Nano when needed and loads it, reporting download progress */ prepare: (options?: AdkPrepareOptions) => Promise - updateTools: (tools: AdkToolDefinitionSet) => void - /** Counts tokens with the Gemini Nano tokenizer. Not available for cloud models */ + /** Counts tokens with the Gemini Nano tokenizer */ countTokens: (text: string) => Promise } export interface AdkProvider { - (options?: AdkLanguageModelId | AdkLanguageModelOptions): AdkLanguageModel + (options?: AdkLanguageModelOptions): AdkLanguageModel readonly specificationVersion: 'v4' - languageModel: ( - options?: AdkLanguageModelId | AdkLanguageModelOptions - ) => AdkLanguageModel - /** - * Whether the provider's model, or the default model of `modelType`, can be - * used now: its availability is `available` or `downloadable` - */ - isAvailable: (modelType?: AdkModelType) => Promise - /** Availability details for the provider's model, or for `model` */ + languageModel: (options?: AdkLanguageModelOptions) => AdkLanguageModel + /** Whether Gemini Nano can be used now: it is `available` or `downloadable` */ + isAvailable: () => Promise + /** Gemini Nano's availability, for the provider's model selection or `nano` */ getModelInfo: (options?: { - model?: AdkLanguageModelId nano?: AdkNanoModelConfig }) => Promise - /** @deprecated Check `(await getModelInfo()).availability` instead */ - isNanoSupported: () => Promise - /** @deprecated Use `prepare()` on a Gemini Nano model */ - prepareNano: (options?: AdkPrepareOptions) => Promise -} - -type ResolvedModelOptions = Omit< - AdkLanguageModelOptions, - 'model' | 'modelType' | 'modelName' -> & { - model: string - modelType: AdkModelType -} - -function resolveModelOptions( - defaults: AdkLanguageModelOptions, - options: AdkLanguageModelId | AdkLanguageModelOptions = {} -): ResolvedModelOptions { - const overrides = typeof options === 'string' ? { model: options } : options - const { - model: defaultModel, - modelName: defaultModelName, - ...defaultRest - } = defaults - const { model, modelName, ...rest } = overrides - const merged = { ...defaultRest, ...rest } - const id = model ?? modelName ?? defaultModel ?? defaultModelName - const modelType = - merged.modelType ?? - (id && id !== DEFAULT_NANO_MODEL ? 'gemini' : 'genai-nano') - - return { - ...merged, - modelType, - model: - id ?? - (modelType === 'gemini' ? DEFAULT_GEMINI_MODEL : DEFAULT_NANO_MODEL), - } } const toModelAvailability = (value: string): AdkModelAvailability => { @@ -196,30 +115,19 @@ const listenForDownloadProgress = ( : null async function getModelInfo( - { model, modelType }: ResolvedModelOptions, nano: AdkNanoModelConfig | undefined ): Promise { - const supportsTokenCounting = modelType === 'genai-nano' - if (Platform.OS !== 'android') { - return { - model, - modelType, - availability: 'unavailable', - supportsTokenCounting, - } + return { availability: 'unavailable' } } const info = await getNativeAdkEngine() - .getModelInfo(modelType, nano) + .getModelInfo(nano) .catch((error: unknown) => { throw toAdkError(error) }) return { - model, - modelType, availability: toModelAvailability(info.availability), - supportsTokenCounting, baseModelName: info.baseModelName, contextSize: info.contextSize, } @@ -228,78 +136,25 @@ async function getModelInfo( export function createAdkProvider( defaults: AdkLanguageModelOptions = {} ): AdkProvider { - const createLanguageModel = ( - options?: AdkLanguageModelId | AdkLanguageModelOptions - ): AdkLanguageModel => - new AdkChatLanguageModel(resolveModelOptions(defaults, options)) - - const provider = function ( - options?: AdkLanguageModelId | AdkLanguageModelOptions - ) { + const createLanguageModel = (options?: AdkLanguageModelOptions) => + new AdkChatLanguageModel({ ...defaults, ...options }) + + const provider = function (options?: AdkLanguageModelOptions) { return createLanguageModel(options) } provider.specificationVersion = 'v4' as const provider.languageModel = createLanguageModel - provider.isAvailable = async (modelType?: AdkModelType) => { - const resolved = modelType - ? resolveModelOptions({}, { modelType }) - : resolveModelOptions(defaults) - const { availability } = await getModelInfo(resolved, defaults.nano) + provider.isAvailable = async () => { + const { availability } = await getModelInfo(defaults.nano) return availability === 'available' || availability === 'downloadable' } - provider.getModelInfo = ( - options: { model?: AdkLanguageModelId; nano?: AdkNanoModelConfig } = {} - ) => - getModelInfo( - options.model - ? resolveModelOptions({}, options.model) - : resolveModelOptions(defaults), - options.nano ?? defaults.nano - ) - provider.isNanoSupported = async () => { - const { availability } = await getModelInfo( - resolveModelOptions({}, DEFAULT_NANO_MODEL), - defaults.nano - ) - return availability !== 'unavailable' && availability !== 'unknown' - } - provider.prepareNano = (options?: AdkPrepareOptions) => - createLanguageModel({ - model: DEFAULT_NANO_MODEL, - modelType: 'genai-nano', - }).prepare(options) + provider.getModelInfo = (options: { nano?: AdkNanoModelConfig } = {}) => + getModelInfo(options.nano ?? defaults.nano) return provider } export const adk = createAdkProvider() -type Tool = LanguageModelV4FunctionTool | LanguageModelV4ProviderTool - -const toolChoiceWarning: SharedV4Warning = { - type: 'unsupported', - feature: 'toolChoice', - details: 'ADK runs tools natively and cannot be required to call a tool.', -} - -function prepareToolChoice( - tools: Tool[] = [], - toolChoice: LanguageModelV4CallOptions['toolChoice'] -): { tools: Tool[]; warnings: SharedV4Warning[] } { - switch (toolChoice?.type) { - case 'none': - return { tools: [], warnings: [] } - case 'required': - return { tools, warnings: [toolChoiceWarning] } - case 'tool': - return { - tools: tools.filter((tool) => tool.name === toolChoice.toolName), - warnings: [toolChoiceWarning], - } - default: - return { tools, warnings: [] } - } -} - // Gemini thinking budgets for the AI SDK reasoning levels const thinkingBudgets = { minimal: 512, @@ -314,14 +169,6 @@ function prepareThinking( reasoning: LanguageModelV4CallOptions['reasoning'], adkOptions: AdkProviderOptions ): AdkGenerationOptions['thinking'] { - if (adkOptions.thinkingBudget !== undefined) { - return { - includeThoughts: - adkOptions.includeThoughts ?? adkOptions.thinkingBudget !== 0, - budget: adkOptions.thinkingBudget, - } - } - switch (reasoning) { case undefined: case 'provider-default': @@ -389,11 +236,6 @@ const convertFinishReason = ( unified = 'length' } else if (contentFilterReasons.has(finishReason)) { unified = 'content-filter' - } else if ( - finishReason === 'MALFORMED_FUNCTION_CALL' || - finishReason === 'UNEXPECTED_TOOL_CALL' - ) { - unified = 'error' } return { @@ -454,17 +296,6 @@ const getAbortReason = (signal: AbortSignal) => { return error } -const stringifyToolOutput = (value: unknown) => - typeof value === 'string' ? value : JSON.stringify(value ?? null) - -const parseToolResult = (output: string): NonNullable => { - try { - return (JSON.parse(output) as JSONValue) ?? {} - } catch { - return output - } -} - class AdkChatLanguageModel implements AdkLanguageModel { readonly specificationVersion = 'v4' readonly supportedUrls = { @@ -472,82 +303,48 @@ class AdkChatLanguageModel implements AdkLanguageModel { } readonly provider = 'adk' - readonly modelId: string + readonly modelId = MODEL_ID private readonly agentConfig: AdkAgentConfig - private tools: AdkToolDefinitionSet = {} - private nanoPreparePromise: Promise | null = null + private preparePromise: Promise | null = null - constructor(options: ResolvedModelOptions) { - this.modelId = options.model + constructor(options: AdkLanguageModelOptions) { this.agentConfig = { name: options.name ?? 'react_native_adk_agent', description: options.description ?? 'React Native ADK agent', instruction: options.instruction, - model: { - type: options.modelType, - name: options.model, - apiKey: options.apiKey, - nano: options.nano, - }, + nano: options.nano, } - this.updateTools(options.availableTools ?? {}) - } - - private get isNano() { - return this.agentConfig.model.type === 'genai-nano' - } - - updateTools(tools: AdkToolDefinitionSet) { - this.tools = tools } async prepare(options: AdkPrepareOptions = {}): Promise { - if (!this.isNano) { - return - } - const listener = listenForDownloadProgress(options.onProgress) try { - await this.ensureNanoPrepared() + await this.ensurePrepared() } finally { listener?.remove() } } async countTokens(text: string): Promise { - if (!this.isNano) { - throw createAdkError( - 'Token counting is only available for Gemini Nano.', - AdkErrorCodes.ModelUnavailable - ) - } - try { - return await getNativeAdkEngine().countTokens( - text, - this.agentConfig.model.nano - ) + return await getNativeAdkEngine().countTokens(text, this.agentConfig.nano) } catch (error) { throw toAdkError(error) } } - private ensureNanoPrepared(): Promise { - if (!this.isNano) { - return Promise.resolve() - } - - if (!this.nanoPreparePromise) { - this.nanoPreparePromise = getNativeAdkEngine() - .prepareNano(this.agentConfig.model.nano) + private ensurePrepared(): Promise { + if (!this.preparePromise) { + this.preparePromise = getNativeAdkEngine() + .prepareNano(this.agentConfig.nano) .catch((error: unknown) => { - this.nanoPreparePromise = null + this.preparePromise = null throw toAdkError(error) }) } - return this.nanoPreparePromise + return this.preparePromise } private prepareMessages( @@ -576,29 +373,18 @@ class AdkChatLanguageModel implements AdkLanguageModel { } if (message.role === 'assistant') { - // ADK replays history as text, so earlier tool steps become text too const content = message.content .flatMap((part) => { switch (part.type) { case 'text': return [part.text] - case 'tool-call': - return [ - `[Tool call: ${part.toolName}(${stringifyToolOutput(part.input)})]`, - ] - case 'tool-result': - return [ - `[Tool result for ${part.toolName}: ${stringifyToolOutput( - 'value' in part.output ? part.output.value : part.output - )}]`, - ] case 'reasoning': return [] default: warnings.push({ type: 'unsupported', feature: `assistant ${part.type} parts`, - details: 'ADK replays assistant messages as text only.', + details: 'Gemini Nano only takes text history.', }) return [] } @@ -608,24 +394,12 @@ class AdkChatLanguageModel implements AdkLanguageModel { return [{ role: 'assistant', content }] } - if (message.role === 'tool') { - const content = message.content - .filter((part) => part.type === 'tool-result') - .map((part) => { - if (part.output.type === 'execution-denied') { - return part.output.reason ?? 'Execution denied' - } - return stringifyToolOutput(part.output.value) - }) - .join('\n') - - return [{ role: 'user', content }] - } - - throw createAdkError( - 'Unsupported message role for ADK provider', - AdkErrorCodes.InvalidMessage - ) + warnings.push({ + type: 'unsupported', + feature: 'tool messages', + details: "ADK's ML Kit model has no tool calling for Gemini Nano.", + }) + return [] }) } @@ -654,171 +428,52 @@ class AdkChatLanguageModel implements AdkLanguageModel { const adkOptions = (options.providerOptions?.adk ?? {}) as AdkProviderOptions - if (this.isNano) { - // ADK's ML Kit model only passes on temperature, topK and maxOutputTokens - const unsupported = { - topP: options.topP, - seed: options.seed, - stopSequences: options.stopSequences, - presencePenalty: options.presencePenalty, - frequencyPenalty: options.frequencyPenalty, - // ADK's ML Kit model has no response schema or JSON mode - responseFormat: - options.responseFormat?.type === 'json' ? 'json' : undefined, - } - for (const [feature, value] of Object.entries(unsupported)) { - if (value !== undefined) { - warnings.push({ - type: 'unsupported', - feature, - details: 'Gemini Nano does not support this setting.', - }) - } - } - } - - return { - temperature: options.temperature, - maxTokens: options.maxOutputTokens, + // ADK's ML Kit model only passes on temperature, topK, maxOutputTokens + // and thinking, and has no tool calling or JSON mode + const unsupported = { topP: options.topP, - topK: options.topK, seed: options.seed, stopSequences: options.stopSequences, presencePenalty: options.presencePenalty, frequencyPenalty: options.frequencyPenalty, responseFormat: - options.responseFormat?.type === 'json' && !this.isNano - ? { - type: 'json', - mimeType: 'application/json', - schema: options.responseFormat.schema, - } - : undefined, - thinking: prepareThinking(options.reasoning, adkOptions), + options.responseFormat?.type === 'json' ? 'json' : undefined, + tools: options.tools?.length ? options.tools : undefined, } - } - - private prepareTools(tools: Tool[], warnings: SharedV4Warning[]) { - if (this.isNano && tools.length > 0) { - warnings.push({ - type: 'unsupported', - feature: 'tools', - details: "ADK's ML Kit model has no tool calling for Gemini Nano.", - }) - return [] - } - - const functionTools = tools.filter( - (tool): tool is LanguageModelV4FunctionTool => { - if (tool.type === 'function') { - return true - } + for (const [feature, value] of Object.entries(unsupported)) { + if (value !== undefined) { warnings.push({ type: 'unsupported', - feature: `provider-defined tool ${tool.name}`, - }) - return false - } - ) - - for (const tool of functionTools) { - if (!this.tools[tool.name]?.execute) { - warnings.push({ - type: 'other', - message: `Tool "${tool.name}" has no executor. Pass it to createAdkProvider via availableTools so ADK can run it.`, + feature, + details: 'Gemini Nano does not support this setting.', }) } } - return functionTools.map( - (tool): AdkTool => ({ - name: tool.name, - description: tool.description ?? '', - inputSchema: tool.inputSchema, - }) - ) - } - - private async executeTool( - tool: LanguageModelV4FunctionTool, - event: ToolCallEvent - ) { - const execute = this.tools[tool.name]?.execute - if (!execute) { - return { error: `Tool "${tool.name}" is not available in this app.` } - } - - const input = await parseJSON({ - text: event.arguments, - schema: jsonSchema(tool.inputSchema), - }) - const options: ToolExecutionOptions = { - toolCallId: event.toolCallId, - messages: [], - context: undefined, + return { + temperature: options.temperature, + maxTokens: options.maxOutputTokens, + topK: options.topK, + thinking: prepareThinking(options.reasoning, adkOptions), } - return execute(input, options) } private prepareCall(options: LanguageModelV4CallOptions) { - const { tools, warnings } = prepareToolChoice( - options.tools, - options.toolChoice - ) + const warnings: SharedV4Warning[] = [] const messages = this.prepareMessages(options.prompt, warnings) const generationOptions = this.prepareGenerationOptions(options, warnings) return { messages, generationOptions, - tools, - nativeTools: this.prepareTools(tools, warnings), agentConfig: this.prepareAgentConfig(options), warnings, } } - // Runs the tools that native code calls during `runId` - private listenForToolCalls(runId: string, tools: Tool[]) { - const native = getNativeAdkEngine() - - return native.onToolCall(async (event: ToolCallEvent) => { - if (event.runId !== runId) { - return - } - - const tool = tools.find( - (candidate): candidate is LanguageModelV4FunctionTool => - candidate.type === 'function' && candidate.name === event.toolName - ) - let result: unknown - try { - result = tool - ? await this.executeTool(tool, event) - : { error: `Tool not found: ${event.toolName}` } - } catch (error) { - result = { - error: error instanceof Error ? error.message : String(error), - } - } - // Always JSON, so native code can tell strings from other values - native.submitToolResult( - runId, - event.toolCallId, - JSON.stringify(result ?? null) - ) - }) - } - async doGenerate(options: LanguageModelV4CallOptions) { - const { - messages, - generationOptions, - tools, - nativeTools, - agentConfig, - warnings, - } = this.prepareCall(options) + const { messages, generationOptions, agentConfig, warnings } = + this.prepareCall(options) const runId = generateId() const native = getNativeAdkEngine() const abortSignal = options.abortSignal @@ -832,42 +487,22 @@ class AdkChatLanguageModel implements AdkLanguageModel { .cancelStream(runId) .catch((error) => console.warn('[adk] cancel failed:', error)) } - - const toolListener = this.listenForToolCalls(runId, tools) abortSignal?.addEventListener('abort', onAbort, { once: true }) try { - await this.ensureNanoPrepared() + await this.ensurePrepared() const response = await native.generateText( runId, messages, agentConfig, - generationOptions, - nativeTools + generationOptions ) const content: LanguageModelV4Content[] = [] if (response.reasoning) { content.push({ type: 'reasoning', text: response.reasoning }) } - for (const toolCall of response.toolCalls ?? []) { - content.push({ - type: 'tool-call', - toolCallId: toolCall.toolCallId, - toolName: toolCall.toolName, - input: toolCall.input, - providerExecuted: true, - }) - } - for (const toolResult of response.toolResults ?? []) { - content.push({ - type: 'tool-result', - toolCallId: toolResult.toolCallId, - toolName: toolResult.toolName, - result: parseToolResult(toolResult.output), - }) - } content.push({ type: 'text', text: response.content }) return { @@ -883,19 +518,12 @@ class AdkChatLanguageModel implements AdkLanguageModel { throw toAdkError(error) } finally { abortSignal?.removeEventListener('abort', onAbort) - toolListener.remove() } } async doStream(options: LanguageModelV4CallOptions) { - const { - messages, - generationOptions, - tools, - nativeTools, - agentConfig, - warnings, - } = this.prepareCall(options) + const { messages, generationOptions, agentConfig, warnings } = + this.prepareCall(options) const streamId = generateId() const native = getNativeAdkEngine() const abortSignal = options.abortSignal @@ -912,8 +540,6 @@ class AdkChatLanguageModel implements AdkLanguageModel { let listeners: { remove(): void }[] = [] let cleanedUp = false - const toolListener = this.listenForToolCalls(streamId, tools) - const toolNames = new Map() let onAbort = () => {} @@ -927,7 +553,6 @@ class AdkChatLanguageModel implements AdkLanguageModel { }) listeners = [] abortSignal?.removeEventListener('abort', onAbort) - toolListener.remove() } const cancelNative = () => { @@ -998,60 +623,6 @@ class AdkChatLanguageModel implements AdkLanguageModel { }) ) - addListener( - native.onStreamToolCall((data: StreamToolCallEvent) => { - if (data.streamId !== streamId) { - return - } - - if (data.phase === 'start' && data.toolName) { - closeReasoning() - toolNames.set(data.toolCallId, data.toolName) - controller.enqueue({ - type: 'tool-input-start', - id: data.toolCallId, - toolName: data.toolName, - providerExecuted: true, - }) - return - } - - if (data.phase === 'delta' && data.inputDelta) { - controller.enqueue({ - type: 'tool-input-delta', - id: data.toolCallId, - delta: data.inputDelta, - }) - return - } - - if (data.phase === 'end' && data.toolName && data.input) { - controller.enqueue({ - type: 'tool-input-end', - id: data.toolCallId, - }) - controller.enqueue({ - type: 'tool-call', - toolCallId: data.toolCallId, - toolName: data.toolName, - input: data.input, - providerExecuted: true, - }) - return - } - - if (data.phase === 'result' && data.output !== undefined) { - controller.enqueue({ - type: 'tool-result', - toolCallId: data.toolCallId, - toolName: - data.toolName ?? toolNames.get(data.toolCallId) ?? 'unknown', - result: parseToolResult(data.output), - }) - } - }) - ) - addListener( native.onStreamComplete((data) => { if (data.streamId !== streamId) { @@ -1085,14 +656,13 @@ class AdkChatLanguageModel implements AdkLanguageModel { ) try { - await this.ensureNanoPrepared() + await this.ensurePrepared() await native.streamText( streamId, messages, agentConfig, - generationOptions, - nativeTools + generationOptions ) } catch (error) { cleanup() diff --git a/packages/adk/src/errors.ts b/packages/adk/src/errors.ts index 89fd2e65..45e4edd4 100644 --- a/packages/adk/src/errors.ts +++ b/packages/adk/src/errors.ts @@ -9,7 +9,6 @@ export const AdkErrorCodes = { DownloadFailed: 'DOWNLOAD_FAILED', GenerationError: 'GENERATION_ERROR', InvalidMessage: 'INVALID_MESSAGE', - InvalidSchema: 'INVALID_SCHEMA', ContextWindowExceeded: 'CONTEXT_WINDOW_EXCEEDED', RateLimited: 'RATE_LIMITED', BackgroundUseBlocked: 'BACKGROUND_USE_BLOCKED', diff --git a/packages/adk/src/index.ts b/packages/adk/src/index.ts index 64353ce0..3f71d399 100644 --- a/packages/adk/src/index.ts +++ b/packages/adk/src/index.ts @@ -1,14 +1,12 @@ export type { AdkDownloadProgress, AdkLanguageModel, - AdkLanguageModelId, AdkLanguageModelOptions, AdkModelAvailability, AdkModelInfo, AdkPrepareOptions, AdkProvider, AdkProviderOptions, - AdkToolDefinitionSet, } from './ai-sdk' export { adk, createAdkProvider } from './ai-sdk' export type { AdkError, AdkErrorCode } from './errors' @@ -17,8 +15,6 @@ export { type AdkAgentConfig, default as AdkEngine, type AdkMessage, - type AdkModelType, type AdkNanoModelConfig, - type AdkTool, getNativeAdkEngine, } from './NativeAdkEngine' From 11a29b10bc56b194e76d8adfd3b24f0ba8f991d4 Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Thu, 29 Oct 2026 22:08:38 +0100 Subject: [PATCH 10/11] docs(adk): document the gemini nano provider, its availability and preparing Co-Authored-By: Claude Opus 5.5 --- packages/adk/README.md | 13 +- .../src/content/docs/docs/adk/generating.md | 108 ++++++-------- .../content/docs/docs/adk/getting-started.mdx | 17 +-- website/src/content/docs/docs/adk/models.md | 135 ++++++++++-------- 4 files changed, 125 insertions(+), 148 deletions(-) diff --git a/packages/adk/README.md b/packages/adk/README.md index 2ad9b3fd..72f9eec8 100644 --- a/packages/adk/README.md +++ b/packages/adk/README.md @@ -1,12 +1,11 @@ # ADK Provider for Vercel AI SDK -A Vercel AI SDK provider for [Google's Agent Development Kit (ADK)](https://developer.android.com/ai/adk), enabling on-device Gemini Nano and cloud Gemini in React Native applications on Android. +A Vercel AI SDK provider for [Google's Agent Development Kit (ADK)](https://developer.android.com/ai/adk), running Gemini Nano on device in React Native apps on Android. **Requirements:** - Android only, with `minSdkVersion` 26+ set in your app -- A device that supports Gemini Nano through AICore for on-device inference (see [ML Kit GenAI device support](https://developers.google.com/ml-kit/genai#feature-device)) -- A Google AI API key for cloud Gemini +- A device that supports Gemini Nano through AICore (see [ML Kit GenAI device support](https://developers.google.com/ml-kit/genai#feature-device)) - Vercel AI SDK v7 - React Native New Architecture @@ -25,16 +24,14 @@ const { text } = await generateText({ ## Features - ✅ On-device Gemini Nano through ML Kit GenAI, with model selection -- ✅ Cloud Gemini through ADK `LlmAgent` -- ✅ Availability, download progress and token counting for Gemini Nano +- ✅ Availability, download progress and token counting - ✅ Streaming -- ✅ Tool calling, with the agent loop run natively by ADK -- ✅ Structured outputs -- ✅ Reasoning - ✅ Image prompts - ✅ Token usage - ✅ Error codes +ADK's ML Kit model has no tool calling or structured output for Gemini Nano yet, so tools and JSON output return `unsupported` warnings. + ## Documentation For complete installation instructions and API documentation, visit our [documentation site](https://react-native-ai.com/docs/adk). diff --git a/website/src/content/docs/docs/adk/generating.md b/website/src/content/docs/docs/adk/generating.md index a6539eaf..103e465a 100644 --- a/website/src/content/docs/docs/adk/generating.md +++ b/website/src/content/docs/docs/adk/generating.md @@ -3,10 +3,7 @@ title: "Generating" --- Generate text on Android with Gemini Nano: pass `adk()` to the AI SDK's -`generateText` or `streamText`. The examples on this page run on device. For -cloud Gemini, create the model as shown in -[Models & Availability](/docs/adk/models#cloud-gemini); everything else stays -the same. +`generateText` or `streamText`. ## Text Generation @@ -20,9 +17,11 @@ const { text } = await generateText({ }) ``` -The first call prepares Gemini Nano. To avoid the wait, call `adk.prepareNano()` -ahead of time, once [the availability check](/docs/adk/models#availability-check) -passes. +The first call prepares Gemini Nano. To avoid the wait, call +[`prepare()`](/docs/adk/models#preparing) ahead of time. + +System messages and the provider's `instruction` become the ADK agent's +instruction. ## Streaming @@ -55,50 +54,12 @@ const { usage } = await generateText({ console.log(usage.inputTokens) console.log(usage.outputTokens) -console.log(usage.raw?.totalTokenCount) -``` - -## Tool Calling - -Let the model call your JavaScript functions, on device or in the cloud. ADK -runs the tool loop natively, so register each tool with the provider in -`availableTools`, and pass the ones a request may use in `tools` as usual: - -```typescript -import { createAdkProvider } from '@react-native-ai/adk' -import { generateText, tool } from 'ai' -import { z } from 'zod' - -const getCurrentTime = tool({ - description: 'Get the current time for a city', - inputSchema: z.object({ city: z.string() }), - execute: async ({ city }) => ({ - city, - time: new Date().toLocaleTimeString(), - }), -}) - -const adk = createAdkProvider({ - availableTools: { getCurrentTime }, -}) - -const { text } = await generateText({ - model: adk(), - tools: { getCurrentTime }, - prompt: 'What time is it in Warsaw?', -}) ``` -Because ADK runs the loop: - -- AI SDK step controls, such as `stopWhen`, don't limit it. -- Streamed tool calls are marked `providerExecuted: true`. -- A `required` `toolChoice` is ignored with a warning. - ## Image Input -Ask about an image by passing it as a file part, as base64, a data URL or a -`Uint8Array`: +Ask about an image by passing it as a file part, as base64, a data URL, a +`Uint8Array`, or a `file://` or `content://` URL: ```typescript const { text } = await generateText({ @@ -115,28 +76,14 @@ const { text } = await generateText({ }) ``` -File and HTTP URLs aren't supported yet, so read the image first. - -## JSON Output - -Ask for JSON with `Output.json()`: - -```typescript -import { generateText, Output } from 'ai' - -const { output } = await generateText({ - model: adk(), - prompt: 'Return a JSON object with name and age fields.', - output: Output.json(), -}) -``` - -ADK can't constrain the output to a schema or stream JSON yet, so validate -`output` in your app, for example with zod. +HTTP URLs aren't supported, so download the image first. ## Options -`temperature`, `maxOutputTokens`, `topP` and `topK` work as usual: +`temperature`, `maxOutputTokens` and `topK` work as usual. Gemini Nano ignores +`topP`, `seed`, `stopSequences`, `presencePenalty` and `frequencyPenalty` with an +`unsupported` warning. Tools and JSON output return the same warning: ADK's ML +Kit model has no tool calling or structured output yet. ```typescript const { text } = await generateText({ @@ -144,11 +91,38 @@ const { text } = await generateText({ prompt: 'Write a creative story', temperature: 0.8, maxOutputTokens: 500, - topP: 0.9, topK: 40, }) ``` +## Errors + +Errors from the provider have a `code`: + +```typescript +import { AdkErrorCodes } from '@react-native-ai/adk' + +try { + await generateText({ model: adk(), prompt: 'Hello' }) +} catch (error) { + if (error.code === AdkErrorCodes.ModelDownloading) { + // Try again once Android has downloaded Gemini Nano + } +} +``` + +| `code` | Meaning | +| ------------------------- | -------------------------------------------------------- | +| `UNSUPPORTED_PLATFORM` | Not running on Android | +| `MODEL_UNAVAILABLE` | This device can't run Gemini Nano | +| `MODEL_DOWNLOADING` | Android is still downloading Gemini Nano | +| `DOWNLOAD_FAILED` | Downloading Gemini Nano failed | +| `CONTEXT_WINDOW_EXCEEDED` | The request is longer than the model's context | +| `RATE_LIMITED` | Too many requests, or AICore's per-app quota was reached | +| `BACKGROUND_USE_BLOCKED` | Gemini Nano only runs while the app is in the foreground | +| `INVALID_MESSAGE` | The prompt has a part the provider can't send | +| `GENERATION_ERROR` | Any other failure | + :::tip[Long conversations] Gemini Nano has a small context window and every request sends the whole chat. To keep a rolling window and summarize older messages, wrap the model with diff --git a/website/src/content/docs/docs/adk/getting-started.mdx b/website/src/content/docs/docs/adk/getting-started.mdx index b68d91df..ffc2b016 100644 --- a/website/src/content/docs/docs/adk/getting-started.mdx +++ b/website/src/content/docs/docs/adk/getting-started.mdx @@ -6,9 +6,7 @@ import PackageManagerTabs from '../../../../components/starlight/PackageManagerT Run Gemini Nano on Android, on the device, with the Vercel AI SDK. Android provides the model through AICore, so there's no model to bundle and no API key. -When you need a larger model or support for every device, the same provider -runs cloud Gemini. It's built on -[Google's Agent Development Kit](https://developer.android.com/ai/adk). +It's built on [Google's Agent Development Kit](https://developer.android.com/ai/adk). ## Installation @@ -20,10 +18,9 @@ The AI SDK needs its [polyfills](/docs/polyfills). - Android with `minSdkVersion` 26 or higher - React Native 0.76 or newer, with the New Architecture -- For Gemini Nano, a physical device with AICore support, running Android 14 - or newer. See the +- A physical device with AICore support, running Android 14 or newer. See the [ML Kit GenAI documentation](https://developers.google.com/ml-kit/genai#feature-device) - for the supported devices. Cloud Gemini works on any device. + for the supported devices. ## Native Setup @@ -79,7 +76,7 @@ Pass `adk()` to the AI SDK. Check that Gemini Nano can run on the device first: import { adk } from '@react-native-ai/adk' import { generateText } from 'ai' -if (await adk.isAvailable('genai-nano')) { +if (await adk.isAvailable()) { const { text } = await generateText({ model: adk(), prompt: 'Summarize on-device AI in one sentence.', @@ -87,9 +84,9 @@ if (await adk.isAvailable('genai-nano')) { } ``` -[Models & Availability](/docs/adk/models) covers the availability checks and cloud Gemini. +[Models & Availability](/docs/adk/models) covers the availability checks. ## Next Steps -- [Generating](/docs/adk/generating): streaming, tool calling, image input and JSON output -- [Models & Availability](/docs/adk/models): checking for Gemini Nano, cloud Gemini and provider options +- [Generating](/docs/adk/generating): streaming, image input, token usage and errors +- [Models & Availability](/docs/adk/models): checking for Gemini Nano, preparing it and provider options diff --git a/website/src/content/docs/docs/adk/models.md b/website/src/content/docs/docs/adk/models.md index 3d32f5ee..8bda3f54 100644 --- a/website/src/content/docs/docs/adk/models.md +++ b/website/src/content/docs/docs/adk/models.md @@ -3,86 +3,100 @@ title: "Models & Availability" --- `adk()` runs Gemini Nano on the device. Android provides it through AICore, so -there's nothing to download or bundle, but only some devices can run it. When -you need a larger model, or support for every device, use cloud Gemini. +there's nothing to bundle and no API key, but only some devices can run it. -| Model | `modelType` | `modelName` | Runs | -| ------------ | ------------ | ------------------------------ | -------------------------------- | -| Gemini Nano | `genai-nano` | `gemini-nano` (the default) | On device, offline, no API key | -| Cloud Gemini | `gemini` | Required, such as `gemini-2.5-flash` | Google AI API, with your API key | +## Availability -## Gemini Nano - -### Availability Check - -Check before you offer Gemini Nano in your app. There are two checks, both -cheap and safe to run at startup and again when the app resumes: - -| Call | Answers | -| ------------------------------- | ------------------------------------------------ | -| `adk.isNanoSupported()` | Can this device ever run Gemini Nano? | -| `adk.isAvailable('genai-nano')` | Can it run now, or is it still being downloaded? | +Check before you offer Gemini Nano in your app. `adk.getModelInfo()` reports +ML Kit's status for the model: ```typescript import { adk } from '@react-native-ai/adk' -if (!(await adk.isNanoSupported())) { - // Hide Gemini Nano: this device can't run it - return +const info = await adk.getModelInfo() + +switch (info.availability) { + case 'available': + // Ready to generate + break + case 'downloadable': + // Supported: prepare() downloads it + break + case 'downloading': + // Android is downloading it, show it as not ready yet + break + case 'unavailable': + case 'unknown': + // This device can't run Gemini Nano, hide it + break } - -if (!(await adk.isAvailable('genai-nano'))) { - // Show it as not ready yet, for example while Android downloads it - return -} - -await adk.prepareNano() -const model = adk() ``` -Both are based on ML Kit's model status. See the +When Gemini Nano is `available`, `getModelInfo()` also returns `baseModelName` +and `contextSize`, its input token limit. + +`adk.isAvailable()` is the yes/no version: it's `true` when Gemini Nano is +`available` or `downloadable`. Both are cheap, never download anything, and are +safe to call at startup and again when the app resumes. See the [ML Kit GenAI documentation](https://developers.google.com/ml-kit/genai#feature-device) for the supported devices. -### Preparing +## Preparing + +`prepare()` downloads Gemini Nano when needed and loads it, so the first +request doesn't wait. It can report download progress: + +```typescript +import { adk } from '@react-native-ai/adk' + +const model = adk() + +await model.prepare({ + onProgress: ({ phase, bytesDownloaded, bytesToDownload }) => { + // phase is 'started', 'progress' or 'completed' + }, +}) +``` -`adk.prepareNano()` loads Gemini Nano ahead of time. If you skip it, the first `generateText` or `streamText` call prepares it. That call -only checks `isNanoSupported()`, so check `isAvailable('genai-nano')` yourself -before showing the model as ready, and handle errors in your chat flow. +If you skip it, the first `generateText` or `streamText` call prepares the +model. Preparing fails with `MODEL_UNAVAILABLE` on devices that can't run +Gemini Nano, and with `MODEL_DOWNLOADING` while Android is still downloading +it. -## Cloud Gemini +## Model Selection -Use cloud Gemini on devices without Gemini Nano, on the emulator, or when you -need a more capable model. Create a provider with `modelType: 'gemini'`, a -`modelName` and your API key: +ML Kit can run the preview Gemini Nano model, which needs the AICore developer +preview, and can favor speed or quality: ```typescript import { createAdkProvider } from '@react-native-ai/adk' -import { generateText } from 'ai' const adk = createAdkProvider({ - apiKey: process.env.GOOGLE_API_KEY, - modelType: 'gemini', - modelName: 'gemini-2.5-flash', + nano: { releaseStage: 'preview', preference: 'full' }, }) +``` -const { text } = await generateText({ - model: adk(), - prompt: 'What time is it in New York?', -}) +## Token Counting + +`countTokens` counts tokens with the Gemini Nano tokenizer, for example to +check a prompt against `contextSize`: + +```typescript +const tokens = await adk().countTokens('How long is this prompt?') ``` -Cloud models need no download or prepare step. +## What Gemini Nano Supports -:::caution -Don't ship API keys in your app. Use a backend proxy or load the key securely -at runtime. -::: +ADK runs Gemini Nano through ML Kit's Prompt API, which supports text and image +prompts, streaming, `temperature`, `topK` and `maxOutputTokens`. ADK's ML Kit +model has no tool calling or structured output yet: tools and JSON output +return an `unsupported` warning, and so do `topP`, `seed`, stop sequences and +penalties. ## Provider Options -`createAdkProvider` creates a provider with its own settings, for example a -system instruction: +`createAdkProvider` creates a provider with its own defaults, and `adk()` takes +the same options for a single model: ```typescript import { createAdkProvider } from '@react-native-ai/adk' @@ -90,16 +104,11 @@ import { createAdkProvider } from '@react-native-ai/adk' const adk = createAdkProvider({ instruction: 'You are a concise, friendly assistant.', }) - -const model = adk() ``` -| Option | Type | Description | -| ---------------- | -------------------------- | ----------------------------------------------------------------- | -| `modelType` | `'genai-nano' \| 'gemini'` | On device or cloud (default: `genai-nano`) | -| `modelName` | `string` | Model name (default: `gemini-nano`; set it for cloud Gemini) | -| `apiKey` | `string` | Google AI API key, for cloud Gemini only | -| `instruction` | `string` | System instruction | -| `availableTools` | `Record` | Tools ADK can call, see [Tool Calling](/docs/adk/generating#tool-calling) | -| `name` | `string` | ADK agent name (default: `react_native_adk_agent`) | -| `description` | `string` | ADK agent description | +| Option | Type | Description | +| ------------- | -------- | -------------------------------------------------- | +| `instruction` | `string` | System instruction | +| `nano` | `object` | Gemini Nano [model selection](#model-selection) | +| `name` | `string` | ADK agent name (default: `react_native_adk_agent`) | +| `description` | `string` | ADK agent description | From 92f968bca9e1b3e1cad6978aef8c743a2771363d Mon Sep 17 00:00:00 2001 From: Mike Grabowski Date: Thu, 29 Oct 2026 23:28:43 +0100 Subject: [PATCH 11/11] fix(adk): take the gemini-nano model id and reject other ids AI SDK providers take a model id, such as from a provider registry, but the provider only took options, so adk('gemini-nano') spread a string into them and any other id or model option silently ran Gemini Nano. Take 'gemini-nano' as an id or the model option, as apple does, and throw NoSuchModelError for any other id. Co-Authored-By: Claude Opus 5.5 --- packages/adk/src/__tests__/ai-sdk.test.ts | 19 ++++++++ packages/adk/src/ai-sdk.ts | 54 +++++++++++++++------ packages/adk/src/index.ts | 1 + website/src/content/docs/docs/adk/models.md | 4 ++ 4 files changed, 63 insertions(+), 15 deletions(-) diff --git a/packages/adk/src/__tests__/ai-sdk.test.ts b/packages/adk/src/__tests__/ai-sdk.test.ts index 761031c6..d1dec5b9 100644 --- a/packages/adk/src/__tests__/ai-sdk.test.ts +++ b/packages/adk/src/__tests__/ai-sdk.test.ts @@ -68,6 +68,7 @@ mock.module('react-native', () => ({ })) const { createAdkProvider } = await import('../ai-sdk') +const { NoSuchModelError } = await import('@ai-sdk/provider') const nano = createAdkProvider()() @@ -125,6 +126,24 @@ describe('provider', () => { expect(nano.provider).toBe('adk') }) + test('takes the gemini-nano model id', () => { + expect(createAdkProvider()('gemini-nano').modelId).toBe('gemini-nano') + expect( + createAdkProvider().languageModel({ model: 'gemini-nano' }).modelId + ).toBe('gemini-nano') + }) + + test('rejects other model ids', () => { + const provider = createAdkProvider() + + expect(() => provider.languageModel('gemini-3.8-flash' as never)).toThrow( + NoSuchModelError + ) + expect(() => provider({ model: 'gemini-3.8-flash' as never })).toThrow( + NoSuchModelError + ) + }) + test('reports Gemini Nano availability', async () => { getModelInfo.mockImplementationOnce(async () => ({ availability: 'available', diff --git a/packages/adk/src/ai-sdk.ts b/packages/adk/src/ai-sdk.ts index 49c5a928..66d440ae 100644 --- a/packages/adk/src/ai-sdk.ts +++ b/packages/adk/src/ai-sdk.ts @@ -1,13 +1,14 @@ -import type { - LanguageModelV4, - LanguageModelV4CallOptions, - LanguageModelV4Content, - LanguageModelV4FilePart, - LanguageModelV4FinishReason, - LanguageModelV4Prompt, - LanguageModelV4StreamPart, - LanguageModelV4Usage, - SharedV4Warning, +import { + type LanguageModelV4, + type LanguageModelV4CallOptions, + type LanguageModelV4Content, + type LanguageModelV4FilePart, + type LanguageModelV4FinishReason, + type LanguageModelV4Prompt, + type LanguageModelV4StreamPart, + type LanguageModelV4Usage, + NoSuchModelError, + type SharedV4Warning, } from '@ai-sdk/provider' import { generateId, resolveFullMediaType } from '@ai-sdk/provider-utils' import { Platform } from 'react-native' @@ -26,7 +27,12 @@ import { const MODEL_ID = 'gemini-nano' +/** ADK runs Gemini Nano, the one model ML Kit provides on the device */ +export type AdkLanguageModelId = typeof MODEL_ID + export interface AdkLanguageModelOptions { + /** The model to run, `gemini-nano` */ + model?: AdkLanguageModelId /** ADK agent name */ name?: string /** ADK agent description */ @@ -76,9 +82,11 @@ export interface AdkLanguageModel extends LanguageModelV4 { } export interface AdkProvider { - (options?: AdkLanguageModelOptions): AdkLanguageModel + (options?: AdkLanguageModelId | AdkLanguageModelOptions): AdkLanguageModel readonly specificationVersion: 'v4' - languageModel: (options?: AdkLanguageModelOptions) => AdkLanguageModel + languageModel: ( + options?: AdkLanguageModelId | AdkLanguageModelOptions + ) => AdkLanguageModel /** Whether Gemini Nano can be used now: it is `available` or `downloadable` */ isAvailable: () => Promise /** Gemini Nano's availability, for the provider's model selection or `nano` */ @@ -136,10 +144,26 @@ async function getModelInfo( export function createAdkProvider( defaults: AdkLanguageModelOptions = {} ): AdkProvider { - const createLanguageModel = (options?: AdkLanguageModelOptions) => - new AdkChatLanguageModel({ ...defaults, ...options }) + const createLanguageModel = ( + options: AdkLanguageModelId | AdkLanguageModelOptions = {} + ) => { + const modelOptions = + typeof options === 'string' ? { model: options } : options + const model = modelOptions.model ?? defaults.model ?? MODEL_ID + // The AI SDK passes any id, such as from a provider registry + if (model !== MODEL_ID) { + throw new NoSuchModelError({ + modelId: model, + modelType: 'languageModel', + message: `ADK only runs ${MODEL_ID} on the device, not ${model}.`, + }) + } + return new AdkChatLanguageModel({ ...defaults, ...modelOptions }) + } - const provider = function (options?: AdkLanguageModelOptions) { + const provider = function ( + options?: AdkLanguageModelId | AdkLanguageModelOptions + ) { return createLanguageModel(options) } provider.specificationVersion = 'v4' as const diff --git a/packages/adk/src/index.ts b/packages/adk/src/index.ts index 3f71d399..96f83666 100644 --- a/packages/adk/src/index.ts +++ b/packages/adk/src/index.ts @@ -1,6 +1,7 @@ export type { AdkDownloadProgress, AdkLanguageModel, + AdkLanguageModelId, AdkLanguageModelOptions, AdkModelAvailability, AdkModelInfo, diff --git a/website/src/content/docs/docs/adk/models.md b/website/src/content/docs/docs/adk/models.md index 8bda3f54..7a9acd08 100644 --- a/website/src/content/docs/docs/adk/models.md +++ b/website/src/content/docs/docs/adk/models.md @@ -112,3 +112,7 @@ const adk = createAdkProvider({ | `nano` | `object` | Gemini Nano [model selection](#model-selection) | | `name` | `string` | ADK agent name (default: `react_native_adk_agent`) | | `description` | `string` | ADK agent description | + +`adk()` also takes the model id, `adk('gemini-nano')`, as AI SDK providers do. +Any other id throws the AI SDK's `NoSuchModelError`, since ADK only runs Gemini +Nano.