Add Tool Calling and Reasoning Token Metadata to genai_config.json with Fallback Map

src/config.cpp

@@ -1181,6 +1181,14 @@ struct Model_Element : JSON::Element {
       v_.left_context_samples = SafeDoubleToInt(JSON::Get<double>(value), name);
     } else if (name == "right_context_samples") {
       v_.right_context_samples = SafeDoubleToInt(JSON::Get<double>(value), name);
+    } else if (name == "bot_token_id") {
+      v_.bot_token_id = SafeDoubleToInt(JSON::Get<double>(value), name);
+    } else if (name == "eot_token_id") {
+      v_.eot_token_id = SafeDoubleToInt(JSON::Get<double>(value), name);
+    } else if (name == "bor_token_id") {
+      v_.bor_token_id = SafeDoubleToInt(JSON::Get<double>(value), name);
+    } else if (name == "eor_token_id") {
+      v_.eor_token_id = SafeDoubleToInt(JSON::Get<double>(value), name);
     } else {
       throw JSON::unknown_value_error{};
     }
@@ -1416,13 +1424,27 @@ static std::string EscapeJsonString(std::string_view s) {
   result.reserve(s.size());
   for (char c : s) {
     switch (c) {
-      case '"':  result += "\\\""; break;
-      case '\\': result += "\\\\"; break;
-      case '\b': result += "\\b";  break;
-      case '\f': result += "\\f";  break;
-      case '\n': result += "\\n";  break;
-      case '\r': result += "\\r";  break;
-      case '\t': result += "\\t";  break;
+      case '"':
+        result += "\\\"";
+        break;
+      case '\\':
+        result += "\\\\";
+        break;
+      case '\b':
+        result += "\\b";
+        break;
+      case '\f':
+        result += "\\f";
+        break;
+      case '\n':
+        result += "\\n";
+        break;
+      case '\r':
+        result += "\\r";
+        break;
+      case '\t':
+        result += "\\t";
+        break;
       default:
         if (static_cast<unsigned char>(c) < 0x20) {
           throw std::runtime_error(

src/config.h

@@ -145,6 +145,16 @@ struct Config {
     int video_token_id{};
     int vision_start_token_id{};
 
+    // Tool-calling and reasoning token IDs.
+    // Follows the bos/eos/pad naming convention:
+    //   bot = beginning of tool (call), eot = end of tool (call)
+    //   bor = beginning of reasoning,   eor = end of reasoning
+    // -1 means the model does not define this token.
+    int bot_token_id{-1};
+    int eot_token_id{-1};
+    int bor_token_id{-1};
+    int eor_token_id{-1};
+
     int vocab_size{};
     int context_length{};
 

src/csharp/NativeMethods.cs

@@ -268,6 +268,22 @@ public static extern UIntPtr OgaSequencesGetSequenceCount(IntPtr /* const OgaSeq
         public static extern IntPtr /* OgaResult* */ OgaTokenizerGetPadTokenId(IntPtr /* const OgaTokenizer* */ tokenizer,
                                                                                out int /* const int32_t* */ outPadTokenId);
 
+        [DllImport(NativeLib.DllName, CallingConvention = CallingConvention.Winapi)]
+        public static extern IntPtr /* OgaResult* */ OgaTokenizerGetBotTokenId(IntPtr /* const OgaTokenizer* */ tokenizer,
+                                                                               out int /* const int32_t* */ outBotTokenId);
+
+        [DllImport(NativeLib.DllName, CallingConvention = CallingConvention.Winapi)]
+        public static extern IntPtr /* OgaResult* */ OgaTokenizerGetEotTokenId(IntPtr /* const OgaTokenizer* */ tokenizer,
+                                                                               out int /* const int32_t* */ outEotTokenId);
+
+        [DllImport(NativeLib.DllName, CallingConvention = CallingConvention.Winapi)]
+        public static extern IntPtr /* OgaResult* */ OgaTokenizerGetBorTokenId(IntPtr /* const OgaTokenizer* */ tokenizer,
+                                                                               out int /* const int32_t* */ outBorTokenId);
+
+        [DllImport(NativeLib.DllName, CallingConvention = CallingConvention.Winapi)]
+        public static extern IntPtr /* OgaResult* */ OgaTokenizerGetEorTokenId(IntPtr /* const OgaTokenizer* */ tokenizer,
+                                                                               out int /* const int32_t* */ outEorTokenId);
+
         [DllImport(NativeLib.DllName, CallingConvention = CallingConvention.Winapi)]
         public static extern IntPtr /* OgaResult* */ OgaTokenizerEncode(IntPtr /* const OgaTokenizer* */ tokenizer,
                                                                         byte[] /* const char* */ strings,

src/csharp/Tokenizer.cs

@@ -141,6 +141,42 @@ public int GetPadTokenId()
             return padTokenId;
         }
 
+        /// <summary>
+        /// Returns the BOT (beginning of tool call) token ID, or -1 if not defined.
+        /// </summary>
+        public int GetBotTokenId()
+        {
+            Result.VerifySuccess(NativeMethods.OgaTokenizerGetBotTokenId(_tokenizerHandle, out int botTokenId));
+            return botTokenId;
+        }
+
+        /// <summary>
+        /// Returns the EOT (end of tool call) token ID, or -1 if not defined.
+        /// </summary>
+        public int GetEotTokenId()
+        {
+            Result.VerifySuccess(NativeMethods.OgaTokenizerGetEotTokenId(_tokenizerHandle, out int eotTokenId));
+            return eotTokenId;
+        }
+
+        /// <summary>
+        /// Returns the BOR (beginning of reasoning) token ID, or -1 if not defined.
+        /// </summary>
+        public int GetBorTokenId()
+        {
+            Result.VerifySuccess(NativeMethods.OgaTokenizerGetBorTokenId(_tokenizerHandle, out int borTokenId));
+            return borTokenId;
+        }
+
+        /// <summary>
+        /// Returns the EOR (end of reasoning) token ID, or -1 if not defined.
+        /// </summary>
+        public int GetEorTokenId()
+        {
+            Result.VerifySuccess(NativeMethods.OgaTokenizerGetEorTokenId(_tokenizerHandle, out int eorTokenId));
+            return eorTokenId;
+        }
+
         public TokenizerStream CreateStream()
         {
             IntPtr tokenizerStreamHandle = IntPtr.Zero;

src/java/src/main/java/ai/onnxruntime/genai/Tokenizer.java

@@ -107,6 +107,62 @@ public int getPadTokenId() throws GenAIException {
     return tokenizerGetPadTokenId(nativeHandle);
   }
 
+  /**
+   * Gets the BOT (beginning of tool call) token ID, or -1 if the model does not define one.
+   *
+   * @return The BOT token ID.
+   * @throws GenAIException If the call to the GenAI native API fails.
+   */
+  public int getBotTokenId() throws GenAIException {
+    if (nativeHandle == 0) {
+      throw new IllegalStateException("Instance has been freed and is invalid");
+    }
+
+    return tokenizerGetBotTokenId(nativeHandle);
+  }
+
+  /**
+   * Gets the EOT (end of tool call) token ID, or -1 if the model does not define one.
+   *
+   * @return The EOT token ID.
+   * @throws GenAIException If the call to the GenAI native API fails.
+   */
+  public int getEotTokenId() throws GenAIException {
+    if (nativeHandle == 0) {
+      throw new IllegalStateException("Instance has been freed and is invalid");
+    }
+
+    return tokenizerGetEotTokenId(nativeHandle);
+  }
+
+  /**
+   * Gets the BOR (beginning of reasoning) token ID, or -1 if the model does not define one.
+   *
+   * @return The BOR token ID.
+   * @throws GenAIException If the call to the GenAI native API fails.
+   */
+  public int getBorTokenId() throws GenAIException {
+    if (nativeHandle == 0) {
+      throw new IllegalStateException("Instance has been freed and is invalid");
+    }
+
+    return tokenizerGetBorTokenId(nativeHandle);
+  }
+
+  /**
+   * Gets the EOR (end of reasoning) token ID, or -1 if the model does not define one.
+   *
+   * @return The EOR token ID.
+   * @throws GenAIException If the call to the GenAI native API fails.
+   */
+  public int getEorTokenId() throws GenAIException {
+    if (nativeHandle == 0) {
+      throw new IllegalStateException("Instance has been freed and is invalid");
+    }
+
+    return tokenizerGetEorTokenId(nativeHandle);
+  }
+
   /**
    * Gets the end of sentence token IDs.
    *
@@ -229,6 +285,14 @@ public void close() {
 
   private native int[] tokenizerGetEosTokenIds(long tokenizerHandle) throws GenAIException;
 
+  private native int tokenizerGetBotTokenId(long tokenizerHandle) throws GenAIException;
+
+  private native int tokenizerGetEotTokenId(long tokenizerHandle) throws GenAIException;
+
+  private native int tokenizerGetBorTokenId(long tokenizerHandle) throws GenAIException;
+
+  private native int tokenizerGetEorTokenId(long tokenizerHandle) throws GenAIException;
+
   private native int tokenizerToTokenId(long tokenizerHandle, String str) throws GenAIException;
 
   private native String tokenizerApplyChatTemplate(

src/java/src/main/native/ai_onnxruntime_genai_Tokenizer.cpp

@@ -110,6 +110,54 @@ Java_ai_onnxruntime_genai_Tokenizer_tokenizerGetPadTokenId(JNIEnv* env, jobject
   return static_cast<jint>(token_id);
 }
 
+JNIEXPORT jint JNICALL
+Java_ai_onnxruntime_genai_Tokenizer_tokenizerGetBotTokenId(JNIEnv* env, jobject thiz, jlong tokenizer_handle) {
+  const OgaTokenizer* tokenizer = reinterpret_cast<const OgaTokenizer*>(tokenizer_handle);
+  int32_t token_id = 0;
+
+  if (ThrowIfError(env, OgaTokenizerGetBotTokenId(tokenizer, &token_id))) {
+    return 0;
+  }
+
+  return static_cast<jint>(token_id);
+}
+
+JNIEXPORT jint JNICALL
+Java_ai_onnxruntime_genai_Tokenizer_tokenizerGetEotTokenId(JNIEnv* env, jobject thiz, jlong tokenizer_handle) {
+  const OgaTokenizer* tokenizer = reinterpret_cast<const OgaTokenizer*>(tokenizer_handle);
+  int32_t token_id = 0;
+
+  if (ThrowIfError(env, OgaTokenizerGetEotTokenId(tokenizer, &token_id))) {
+    return 0;
+  }
+
+  return static_cast<jint>(token_id);
+}
+
+JNIEXPORT jint JNICALL
+Java_ai_onnxruntime_genai_Tokenizer_tokenizerGetBorTokenId(JNIEnv* env, jobject thiz, jlong tokenizer_handle) {
+  const OgaTokenizer* tokenizer = reinterpret_cast<const OgaTokenizer*>(tokenizer_handle);
+  int32_t token_id = 0;
+
+  if (ThrowIfError(env, OgaTokenizerGetBorTokenId(tokenizer, &token_id))) {
+    return 0;
+  }
+
+  return static_cast<jint>(token_id);
+}
+
+JNIEXPORT jint JNICALL
+Java_ai_onnxruntime_genai_Tokenizer_tokenizerGetEorTokenId(JNIEnv* env, jobject thiz, jlong tokenizer_handle) {
+  const OgaTokenizer* tokenizer = reinterpret_cast<const OgaTokenizer*>(tokenizer_handle);
+  int32_t token_id = 0;
+
+  if (ThrowIfError(env, OgaTokenizerGetEorTokenId(tokenizer, &token_id))) {
+    return 0;
+  }
+
+  return static_cast<jint>(token_id);
+}
+
 JNIEXPORT jintArray JNICALL
 Java_ai_onnxruntime_genai_Tokenizer_tokenizerGetEosTokenIds(JNIEnv* env, jobject thiz, jlong tokenizer_handle) {
   const OgaTokenizer* tokenizer = reinterpret_cast<const OgaTokenizer*>(tokenizer_handle);

src/models/model.cpp

@@ -6,11 +6,13 @@
 #include <algorithm>
 #include <array>
 #include <climits>
+#include <functional>
 #include <random>
 #include <set>
 #include <string>
 #include <string_view>
 #include <thread>
+#include <unordered_map>
 
 #include "../generators.h"
 #include "../search.h"
@@ -306,16 +308,53 @@ const std::string& TokenizerStream::Decode(int32_t token) {
   return chunk_;
 }
 
+// Fallback: if the given token ID is unset (-1), attempt to resolve it by looking up
+// a well-known token string for the model type in the tokenizer vocabulary.
+// This provides backward compatibility for Foundry Local when consuming older model
+// packages that predate the bot/eot/bor/eor config fields.
+// Keyed by model.type string from genai_config.json.
+static void ResolveFallbackTagId(int32_t& id, const std::string& model_type,
+                                 const std::string& tag_name, const Tokenizer& tokenizer) {
+  if (id >= 0) return;
+
+  static const std::unordered_map<std::string, std::unordered_map<std::string, std::string>> fallback_map = {
+      {"qwen2", {{"tool_call_start", "<tool_call>"}, {"tool_call_end", "</tool_call>"}, {"reasoning_start", "<think>"}, {"reasoning_end", "</think>"}}},
+      {"qwen3", {{"tool_call_start", "<tool_call>"}, {"tool_call_end", "</tool_call>"}, {"reasoning_start", "<think>"}, {"reasoning_end", "</think>"}}},
+      {"phi3", {{"tool_call_start", "<|tool_call|>"}, {"tool_call_end", "<|/tool_call|>"}}},
+      {"gptoss", {{"tool_call_start", "<|start|>"}, {"tool_call_end", "<|call|>"}}},
+  };
+
+  auto type_it = fallback_map.find(model_type);
+  if (type_it == fallback_map.end()) return;
+  auto tag_it = type_it->second.find(tag_name);
+  if (tag_it == type_it->second.end()) return;
+
+  int32_t resolved = tokenizer.TokenToTokenId(tag_it->second.c_str());
+  if (resolved >= 0) id = resolved;
+}
+
 Tokenizer::Tokenizer(Config& config) : bos_token_id_{config.model.bos_token_id},
                                        eos_token_id_{config.model.eos_token_id},
-                                       pad_token_id_{config.model.pad_token_id} {
+                                       pad_token_id_{config.model.pad_token_id},
+                                       bot_token_id_{config.model.bot_token_id},
+                                       eot_token_id_{config.model.eot_token_id},
+                                       bor_token_id_{config.model.bor_token_id},
+                                       eor_token_id_{config.model.eor_token_id} {
   // Default tokenizer options
   const char* keys[] = {"add_special_tokens", "skip_special_tokens"};
   const char* values[] = {"false", "true"};
 
   // Resolve tokenizer_dir (may be empty, relative, absolute, or a "sha256:" shared-asset reference).
   const fs::path tokenizer_dir = config.ResolvePath(config.model.tokenizer_dir);
   CheckResult(OrtxCreateTokenizerWithOptions(tokenizer_.Address(), tokenizer_dir.string().c_str(), keys, values, 2));
+
+  // Resolve any unset bot/eot/bor/eor IDs via model-type fallback strings.
+  if (bot_token_id_ < 0 || eot_token_id_ < 0 || bor_token_id_ < 0 || eor_token_id_ < 0) {
+    ResolveFallbackTagId(bot_token_id_, config.model.type, "tool_call_start", *this);
+    ResolveFallbackTagId(eot_token_id_, config.model.type, "tool_call_end", *this);
+    ResolveFallbackTagId(bor_token_id_, config.model.type, "reasoning_start", *this);
+    ResolveFallbackTagId(eor_token_id_, config.model.type, "reasoning_end", *this);
+  }
 }
 
 std::unique_ptr<TokenizerStream> Tokenizer::CreateStream() const {

src/models/model.h

@@ -106,12 +106,26 @@ struct Tokenizer : std::enable_shared_from_this<Tokenizer>, LeakChecked<Tokenize
   const std::vector<int32_t>& GetEosTokenIds() const { return eos_token_id_; }
   int32_t GetPadTokenId() const { return pad_token_id_; }
 
+  // Tool-calling and reasoning token IDs.
+  // Naming follows the bos/eos/pad convention:
+  //   bot = beginning of tool (call), eot = end of tool (call)
+  //   bor = beginning of reasoning,   eor = end of reasoning
+  // Returns -1 if the model does not define the token.
+  int32_t GetBotTokenId() const { return bot_token_id_; }
+  int32_t GetEotTokenId() const { return eot_token_id_; }
+  int32_t GetBorTokenId() const { return bor_token_id_; }
+  int32_t GetEorTokenId() const { return eor_token_id_; }
+
   OrtxPtr<OrtxTokenizer> tokenizer_;
 
  private:
   int32_t bos_token_id_;
   std::vector<int32_t> eos_token_id_;
   int32_t pad_token_id_;
+  int32_t bot_token_id_;
+  int32_t eot_token_id_;
+  int32_t bor_token_id_;
+  int32_t eor_token_id_;
 };
 
 struct MultiModalProcessor : std::enable_shared_from_this<MultiModalProcessor>, ExternalRefCounted<MultiModalProcessor> {

src/objectivec/include/ort_genai_objc.h

@@ -167,6 +167,26 @@ typedef NS_ENUM(NSInteger, OGAElementType) {
  */
 - (int32_t)getPadTokenId:(NSError**)error;
 
+/**
+ * Return the BOT (beginning of tool call) token ID, or -1 if not defined.
+ */
+- (int32_t)getBotTokenId:(NSError**)error;
+
+/**
+ * Return the EOT (end of tool call) token ID, or -1 if not defined.
+ */
+- (int32_t)getEotTokenId:(NSError**)error;
+
+/**
+ * Return the BOR (beginning of reasoning) token ID, or -1 if not defined.
+ */
+- (int32_t)getBorTokenId:(NSError**)error;
+
+/**
+ * Return the EOR (end of reasoning) token ID, or -1 if not defined.
+ */
+- (int32_t)getEorTokenId:(NSError**)error;
+
 /**
  * Encode text to sequences
  *