feat: begin auth0-ai sdk renaming updates, python references

Author: priley86

auth4genai/how-tos/get-github-issues-python.mdx

@@ -39,7 +39,7 @@ Create a function that will return the access token for Github.
 
 ```python wrap lines
 async def get_token_from_token_vault():
-  return await auth0.get_access_token_for_connection(
+  return await auth0.get_access_token_from_token_vault(
       options = {
           "connection" : "github",
           "scope" : "openid profile email offline_access"})

auth4genai/integrations/github.mdx

@@ -96,7 +96,7 @@ To configure the Token Vault for your GitHub connection, you can use the followi
     ```python wrap lines
     auth0_ai = Auth0AI()
 
-    with_github_connection = auth0_ai.with_federated_connection(
+    with_github_connection = auth0_ai.with_token_vault(
         connection="github",
         # scopes are not supported for GitHub yet. Set required scopes when creating the accompanying GitHub app
         scopes=[],

auth4genai/integrations/google.mdx

@@ -162,7 +162,7 @@ To configure the Token Vault for your Google connection, you can use the followi
     ```python wrap lines
     auth0_ai = Auth0AI()
 
-    with_google_connection = auth0_ai.with_federated_connection(
+    with_google_connection = auth0_ai.with_token_vault(
         connection="google-oauth2",
         scopes=["https://www.googleapis.com/auth/calendar.freebusy", ...],
         refresh_token=get_auth0_refresh_token,

auth4genai/integrations/slack.mdx

@@ -96,7 +96,7 @@ To configure the Token Vault for your GitHub connection, you can use the followi
     ```python wrap lines
     auth0_ai = Auth0AI()
 
-    with_slack_connection = auth0_ai.with_federated_connection(
+    with_slack_connection = auth0_ai.with_token_vault(
         connection="sign-in-with-slack",
         scopes=["channels:read", ...],
         refresh_token=get_auth0_refresh_token,

auth4genai/snippets/get-started/langchain-fastapi-py/async-auth.mdx

@@ -34,7 +34,7 @@ Make sure you have [uv](https://docs.astral.sh/uv/) installed and run the follow
 ```bash wrap lines
 cd backend
 uv sync
-uv add "auth0-ai-langchain>=1.0.0b3" "langgraph>=0.5.4" langchain-openai "langgraph-cli[inmem]" --prerelease=allow
+uv add "auth0-ai-langchain>=TODO_NEW_VERSION_HERE" "langgraph>=0.5.4" langchain-openai "langgraph-cli[inmem]>=0.3.6" --prerelease=allow
 ```
 
 ### Update the environment file
@@ -47,7 +47,7 @@ Integrate the Auth0 AI SDK into your application to secure your async AI agent w
 
 #### Configure the Auth0 AI SDK
 
-To require asynchronous authorization for your tool, the tool needs to be wrapped with the Async authorizer, `with_async_user_confirmation()`. Let's create a helper function to wrap the tool with the Async authorizer.
+To require asynchronous authorization for your tool, the tool needs to be wrapped with the Async authorizer, `with_async_authorization()`. Let's create a helper function to wrap the tool with the Async authorizer.
 
 Create a file at `app/core/auth0_ai.py` and instantiate a new Auth0 AI SDK client:
 
@@ -68,8 +68,9 @@ auth0_ai = Auth0AI(
     )
 )
 
-with_async_user_confirmation = auth0_ai.with_async_user_confirmation(
+with_async_authorization = auth0_ai.with_async_authorization(
     audience=settings.SHOP_API_AUDIENCE,
+    # param: scopes
     # add any scopes you want to use with your API
     scopes=["openid", "product:buy"],
     binding_message=lambda product, quantity: f"Do you want to buy {quantity} {product}",
@@ -78,6 +79,12 @@ with_async_user_confirmation = auth0_ai.with_async_user_confirmation(
     .get("_credentials")
     .get("user")
     .get("sub"),
+    # param: requested_expiry
+    # Note: Setting a requested expiry greater than 300 (seconds) will force email verification
+    # instead of using the push notification flow.
+    # requested_expiry=301,
+
+    # param: on_authorization_request
     # When this flag is set to `block`, the execution of the tool awaits
     # until the user approves or rejects the request.
     #
@@ -87,12 +94,13 @@ with_async_user_confirmation = auth0_ai.with_async_user_confirmation(
     # In practice, the process that is awaiting the user confirmation
     # could crash or timeout before the user approves the request.
     on_authorization_request="block",
+
 )
 ```
 
-This will intercept the tool call to initiate a CIBA request:
+This will intercept the tool call to initiate an Async Authorization request:
 
-- The CIBA request includes the user ID that will approve the request.
+- The Async Authorization request includes the user ID that will approve the request.
 - Auth0 sends the user a mobile push notification. The AI agent polls the `/token` endpoint for a user response.
 - The mobile application retrieves the `bindingMessage` containing the consent details, in this case, the details of the product to purchase.
 - The user responds to the request:
@@ -146,10 +154,10 @@ Now, create a file `app/agents/tools/shop_online.py` and add the following code:
 ```python app/agents/tools/shop_online.py wrap lines
 import httpx
 from langchain_core.tools import StructuredTool
-from auth0_ai_langchain.ciba import get_ciba_credentials
+from auth0_ai_langchain.async_authorization import get_async_authorization_credentials
 from pydantic import BaseModel
 
-from app.core.auth0_ai import with_async_user_confirmation
+from app.core.auth0_ai import with_async_authorization
 from app.core.config import settings
 
 
@@ -167,10 +175,10 @@ async def shop_online_fn(product: str, quantity: int):
         # No API set, mock a response
         return f"Ordered {quantity} {product}"
 
-    credentials = get_ciba_credentials()
+    credentials = get_async_authorization_credentials()
 
     if not credentials:
-        raise ValueError("CIBA credentials not found")
+        raise ValueError("Async Authorization credentials not found")
 
     headers = {
         "Authorization": f"Bearer {credentials['access_token']}",
@@ -202,7 +210,7 @@ async def shop_online_fn(product: str, quantity: int):
         }
 
 
-shop_online = with_async_user_confirmation(
+shop_online = with_async_authorization(
     StructuredTool(
         name="shop_online",
         description="Tool to buy products online.",

auth4genai/snippets/get-started/langchain-fastapi-py/auth-for-rag.mdx

@@ -35,7 +35,7 @@ Make sure you have [uv](https://docs.astral.sh/uv/) installed and run the follow
 ```bash wrap lines
 cd backend
 uv sync
-uv add "auth0-ai-langchain>=1.0.0b3" openfga-sdk langgraph langchain-openai "langgraph-cli[inmem]" --prerelease=allow
+uv add "auth0-ai-langchain>=TODO_NEW_VERSION_HERE" openfga-sdk langgraph langchain-openai "langgraph-cli[inmem]" --prerelease=allow
 ```
 
 ### Update the environment file

auth4genai/snippets/get-started/langchain-fastapi-py/call-others-api.mdx

@@ -13,7 +13,7 @@ import { AccountAndAppSteps } from "/snippets/get-started/prerequisites/account-
   <Tab
     title="Use sample app (recommended)"
   >
-  
+
 ### Clone sample app
 Clone this sample app from the [Auth0 AI samples](https://github.com/auth0-samples/auth0-ai-samples) repository:
 
@@ -134,7 +134,7 @@ Make sure you have [uv](https://docs.astral.sh/uv/) installed and run the follow
 ```bash wrap lines
 cd backend
 uv sync
-uv add "auth0-ai-langchain>=1.0.0b3" "langgraph>=0.5.4" langchain-openai "langgraph-cli[inmem]" google-api-python-client --prerelease=allow
+uv add "auth0-ai-langchain>=TODO_NEW_VERSION_HERE" "langgraph>=0.5.4" langchain-openai "langgraph-cli[inmem]>=0.3.6" google-api-python-client --prerelease=allow
 ```
 
 ### Update your environment file
@@ -191,7 +191,7 @@ auth0_ai = Auth0AI(
     )
 )
 
-with_calendar_access = auth0_ai.with_federated_connection(
+with_calendar_access = auth0_ai.with_token_vault(
     connection="google-oauth2",
     scopes=["https://www.googleapis.com/auth/calendar.events"],
 )
@@ -243,8 +243,8 @@ from langchain_core.tools import StructuredTool
 from google.oauth2.credentials import Credentials
 from googleapiclient.discovery import build
 from pydantic import BaseModel
-from auth0_ai_langchain.federated_connections import (
-    get_access_token_for_connection,
+from auth0_ai_langchain.token_vault import (
+    get_access_token_from_token_vault,
 )
 import datetime
 import json
@@ -253,7 +253,7 @@ from app.core.auth0_ai import with_calendar_access
 
 async def list_upcoming_events_fn():
     """List upcoming events from the user's Google Calendar"""
-    google_access_token = get_access_token_for_connection()
+    google_access_token = get_access_token_from_token_vault()
     if not google_access_token:
         raise ValueError(
             "Authorization required to access the Federated Connection API"
@@ -328,18 +328,18 @@ To implement, install the Auth0 AI Components for React SDK to get the required
 ```bash wrap lines
 cd frontend
 npm install @auth0/ai @langchain/langgraph-sdk
-npx @auth0/ai-components add FederatedConnections
+npx @auth0/ai-components add TokenVault
 ```
 
-Add a new file, `src/components/auth0-ai/FederatedConnections/FederatedConnectionInterruptHandler.tsx`, with the following code:
+Add a new file, `src/components/auth0-ai/TokenVault/TokenVaultInterruptHandler.tsx`, with the following code:
 
-```tsx src/components/auth0-ai/FederatedConnections/FederatedConnectionInterruptHandler.tsx wrap lines
-import { FederatedConnectionInterrupt } from "@auth0/ai/interrupts";
+```tsx src/components/auth0-ai/TokenVault/TokenVaultInterruptHandler.tsx wrap lines
+import { TokenVaultInterrupt } from "@auth0/ai/interrupts";
 import type { Interrupt } from "@langchain/langgraph-sdk";
 
-import { EnsureAPIAccess } from "@/components/auth0-ai/FederatedConnections";
+import { TokenVaultConsent } from "@/components/auth0-ai/TokenVault";
 
-interface FederatedConnectionInterruptHandlerProps {
+interface TokenVaultInterruptHandlerProps {
   interrupt: Interrupt | undefined | null;
   onFinish: () => void;
   auth?: {
@@ -348,21 +348,21 @@ interface FederatedConnectionInterruptHandlerProps {
   };
 }
 
-export function FederatedConnectionInterruptHandler({
+export function TokenVaultInterruptHandler({
   interrupt,
   onFinish,
   auth,
-}: FederatedConnectionInterruptHandlerProps) {
+}: TokenVaultInterruptHandlerProps) {
   if (
     !interrupt ||
-    !FederatedConnectionInterrupt.isInterrupt(interrupt.value)
+    !TokenVaultInterrupt.isInterrupt(interrupt.value)
   ) {
     return null;
   }
 
   return (
     <div key={interrupt.ns?.join("")} className="whitespace-pre-wrap">
-      <EnsureAPIAccess
+      <TokenVaultConsent
         mode="popup"
         interrupt={interrupt.value}
         onFinish={onFinish}
@@ -378,11 +378,11 @@ export function FederatedConnectionInterruptHandler({
 }
 ```
 
-Now, update your chat window code to include the `FederatedConnectionInterruptHandler` component, for example:
+Now, update your chat window code to include the `TokenVaultInterruptHandler` component, for example:
 
 ```tsx src/components/chat-window.tsx wrap lines highlight={2,3,25-50}
 //...
-import { FederatedConnectionInterruptHandler } from '@/components/auth0-ai/FederatedConnections/FederatedConnectionInterruptHandler';
+import { TokenVaultInterruptHandler } from '@/components/auth0-ai/TokenVault/TokenVaultInterruptHandler';
 import { getLoginUrl } from "@/lib/use-auth";
 
 //... existing code
@@ -407,7 +407,7 @@ export function ChatWindow(props: {
               />
               <div className="flex flex-col max-w-[768px] mx-auto pb-12 w-full">
                 {!!chat.interrupt?.value && (
-                  <FederatedConnectionInterruptHandler
+                  <TokenVaultInterruptHandler
                     auth={{
                       authorizePath: getLoginUrl(),
                       returnTo: new URL(
@@ -450,4 +450,4 @@ That's it! You successfully integrated third-party API access using Token Vault
 ### View a complete example
 Want to see how it all comes together? Explore or clone the fully implemented sample application on [GitHub](https://github.com/auth0-samples/auth0-ai-samples/tree/main/call-apis-on-users-behalf/others-api/langchain-fastapi-py).
 </Tab>
-</Tabs>
+</Tabs>

auth4genai/snippets/how-tos/github/langgraph-python.mdx

@@ -13,7 +13,7 @@ from auth0_ai_langchain.auth0_ai import Auth0AI
 
 auth0_ai = Auth0AI()
 
-with_github = auth0_ai.with_federated_connection(
+with_github = auth0_ai.with_token_vault(
     connection="github",
     scopes=["repo"]
     # Optional: By default, the SDK will expect the refresh token from
@@ -32,15 +32,15 @@ from github import Github
 from github.GithubException import BadCredentialsException
 from pydantic import BaseModel
 from langchain_core.tools import StructuredTool
-from auth0_ai_langchain.federated_connections import get_access_token_for_connection, FederatedConnectionError
+from auth0_ai_langchain.token_vault import get_access_token_from_token_vault, TokenVaultError
 from src.lib.auth0_ai import with_github
 
 class EmptySchema(BaseModel):
     pass
 
 def list_repositories_tool_function(date: datetime):
     # Get the access token from Auth0 AI
-    access_token = get_access_token_for_connection()
+    access_token = get_access_token_from_token_vault()
 
     # GitHub SDK
     try:
@@ -50,7 +50,7 @@ def list_repositories_tool_function(date: datetime):
         repo_names = [repo.name for repo in repos]
         return repo_names
     except BadCredentialsException:
-        raise FederatedConnectionError("Authorization required to access the Federated Connection API")
+        raise TokenVaultError("Authorization required to access the Token Vault API")
 
 list_github_repositories_tool = with_github(StructuredTool(
     name="list_github_repositories",
@@ -167,18 +167,18 @@ You can check different authentication options for Next.js with Auth0 at the [of
 
 #### Client Side
 
-On this example we utilize the `EnsureAPIAccessPopup` component to show a popup that allows the user to authenticate with GitHub and grant access with the requested scopes. You'll first need to install the `@auth0/ai-components` package:
+On this example we utilize the `TokenVaultConsentPopup` component to show a popup that allows the user to authenticate with GitHub and grant access with the requested scopes. You'll first need to install the `@auth0/ai-components` package:
 
 ```bash wrap lines
-npx @auth0/ai-components add FederatedConnections
+npx @auth0/ai-components add TokenVault
 ```
 
 Then, you can integrate the authentication popup in your chat component, using the interruptions helper from the SDK:
 
 ```tsx ./src/components/chat.tsx wrap lines highlight={2-3,62-74}
 import { useStream } from "@langchain/langgraph-sdk/react";
-import { FederatedConnectionInterrupt } from "@auth0/ai/interrupts";
-import { EnsureAPIAccessPopup } from "@/components/auth0-ai/FederatedConnections/popup";
+import { TokenVaultInterrupt } from "@auth0/ai/interrupts";
+import { TokenVaultConsentPopup } from "@/components/auth0-ai/TokenVault/popup";
 
 const useFocus = () => {
   const htmlElRef = useRef<HTMLInputElement>(null);
@@ -237,9 +237,9 @@ export default function Chat() {
         </div>
       ))}
 
-      {thread.interrupt && FederatedConnectionInterrupt.isInterrupt(thread.interrupt.value) ? (
+      {thread.interrupt && TokenVaultInterrupt.isInterrupt(thread.interrupt.value) ? (
         <div key={thread.interrupt.ns?.join("")}>
-          <EnsureAPIAccessPopup
+          <TokenVaultConsentPopup
             interrupt={thread.interrupt.value}
             onFinish={() => thread.submit(null)}
             connectWidget={{

auth4genai/snippets/how-tos/github/llamaindex-python.mdx

@@ -14,7 +14,7 @@ from flask import session
 
 auth0_ai = Auth0AI()
 
-with_github = auth0_ai.with_federated_connection(
+with_github = auth0_ai.with_token_vault(
     connection="github",
     scopes=["repo"],
     refresh_token=lambda *_args, **_kwargs:session["user"]["refresh_token"],
@@ -32,12 +32,12 @@ Wrap your tool using the Auth0 AI SDK to obtain an access token for the GitHub A
 from github import Github
 from github.GithubException import BadCredentialsException
 from llama_index.core.tools import FunctionTool
-from auth0_ai_llamaindex.federated_connections import get_access_token_for_connection, FederatedConnectionError
+from auth0_ai_llamaindex.token_vault import get_access_token_from_token_vault, TokenVaultError
 from src.lib.auth0_ai import with_github
 
 def list_github_repositories_tool_function():
     # Get the access token from Auth0 AI
-    access_token = get_access_token_for_connection()
+    access_token = get_access_token_from_token_vault()
 
     # GitHub SDK
     try:
@@ -47,7 +47,7 @@ def list_github_repositories_tool_function():
         repo_names = [repo.name for repo in repos]
         return repo_names
     except BadCredentialsException:
-        raise FederatedConnectionError("Authorization required to access the Federated Connection")
+        raise TokenVaultError("Authorization required to access the Token Vault API")
 
 list_github_repositories_tool = with_github(FunctionTool.from_defaults(
     name="list_github_repositories",
@@ -88,14 +88,14 @@ Interrupts are a way for the system to pause execution and prompt the user to ta
 
 On the server side of your Flask application you will need to set up a route to handle the Chat API requests. This route will be responsible for forwarding the requests to the OpenAI API utilizing LlamaIndex's SDK, that has been initialized with Auth0 AI's protection enhancements for tools.
 
-When `FederatedConnectionInterrupt` error ocurrs, the server side will signal the front-end about the level access restrictions, and the front-end should prompt the user to trigger a new authorization (or login) request with the necessary permissions.
+When `TokenVaultInterrupt` error ocurrs, the server side will signal the front-end about the level access restrictions, and the front-end should prompt the user to trigger a new authorization (or login) request with the necessary permissions.
 
 
 ```python ./src/app.py wrap lines highlight={3-5,19-20}
 from dotenv import load_dotenv
 from flask import Flask, request, jsonify, session
 from auth0_ai_llamaindex.auth0_ai import Auth0AI
-from auth0_ai_llamaindex.federated_connections import FederatedConnectionInterrupt
+from auth0_ai_llamaindex.token_vault import TokenVaultInterrupt
 from src.lib.agent import agent
 
 load_dotenv()
@@ -110,7 +110,7 @@ async def chat():
         message = request.json.get("message")
         response = agent.achat(message)
         return jsonify({"response": str(response)})
-    except FederatedConnectionInterrupt as e:
+    except TokenVaultInterrupt as e:
         return jsonify({"error": str(e.to_json())}), 403
     except Exception as e:
         return jsonify({"error": str(e)}), 500