Update gemini docs (#212)

## Description

Fixed errors

Author: AHGIJMKLKKZNPJKQR

api/fishjam-server

@@ -12,7 +12,7 @@ Fishjam publishes documentation for the Sandbox API and Fishjam Server APIs.
 
 [Sandbox API OpenAPI](https://github.com/fishjam-cloud/documentation/tree/main/static/api/room-manager-openapi.yaml)
 
-See also: [What is the Sandbox API?](/explanation/sandbox-api-concept)
+See also: [What is the Sandbox API?](../explanation/sandbox-api-concept)
 
 ## Server
 
@@ -38,7 +38,7 @@ in the `RoomConfig` options when creating a room.
 The HTTP POST to the `webhookUrl` uses "application/x-protobuf" content type.
 The body is binary data, that represents encoded `ServerMessage`.
 
-For more information see also [server setup documentation](/how-to/backend/server-setup#webhooks)
+For more information see also [server setup documentation](../how-to/backend/server-setup#webhooks)
 
 #### Websocket
 

docs/api/reference.md

@@ -52,7 +52,7 @@ Since the Google integration is optional, you need to install the specific depen
     Install Fishjam with the `gemini` extra to pull in the necessary libraries.
 
     ```bash
-    pip install "fishjam[gemini]"
+    pip install "fishjam-server-sdk[gemini]"
     ```
 
   </TabItem>
@@ -89,7 +89,8 @@ We provide a helper factory to initialize the Google Client.
 
     ```python
     import os
-    from fishjam import FishjamClient, GeminiIntegration
+    from fishjam import FishjamClient
+    from fishjam.integrations.gemini import GeminiIntegration
 
     fishjam_client = FishjamClient(
         fishjam_id=os.environ["FISHJAM_ID"],
@@ -112,6 +113,12 @@ Create a Fishjam agent configured to match the audio format that the Google clie
   <TabItem value="ts" label="TypeScript">
 
     ```ts
+    import { FishjamClient } from '@fishjam-cloud/js-server-sdk';
+    const fishjamId = '';
+    const managementToken = '';
+    const fishjamClient = new FishjamClient({ fishjamId, managementToken });
+    
+    // ---cut---
     import GeminiIntegration from '@fishjam-cloud/js-server-sdk/gemini';
 
     const room = await fishjamClient.createRoom();
@@ -129,15 +136,15 @@ Create a Fishjam agent configured to match the audio format that the Google clie
   <TabItem value="python" label="Python">
 
     ```python
-    from fishjam import GeminiIntegration
     from fishjam.peer import SubscribeOptions, SubscribeOptionsAudioSampleRate
     from fishjam.agent import OutgoingAudioTrackOptions, TrackEncoding
+    from fishjam.integrations.gemini import GeminiIntegration
 
     room = fishjam_client.create_room()
 
     # Use our preset to match the required audio format (16kHz)
     # [!code highlight:1]
-    agent_options = AgentOptions(output=GeminiIntegration.GeminiInputAudioSettings)
+    agent_options = AgentOptions(output=GeminiIntegration.GEMINI_INPUT_AUDIO_SETTINGS)
     agent = fishjam_client.create_agent(room.id, agent_options)
     ```
 
@@ -154,27 +161,48 @@ Fishjam handles raw bytes, while Google GenAI SDKs often expect Base64 strings.
   <TabItem value="ts" label="TypeScript">
     Now we setup the callbacks. We need to forward incoming Fishjam audio to Google, and forward incoming Google audio to Fishjam.
     ```ts
-    import GeminiIntegration from '@fishjam-cloud/js-server-sdk/gemini';
+    import { FishjamClient } from '@fishjam-cloud/js-server-sdk';
+    import GI from '@fishjam-cloud/js-server-sdk/gemini';
+
+    const fishjamId = '';
+    const managementToken = '';
+    const fishjamClient = new FishjamClient({ fishjamId, managementToken });
+    const genAi = GI.createClient({
+      apiKey: process.env.GOOGLE_API_KEY!,
+    });
+
+    const room = await fishjamClient.createRoom();
+
+    const { agent } = await fishjamClient.createAgent(room.id, {
+      subscribeMode: 'auto',
+      output: GI.geminiInputAudioSettings,
+    });
+
+    enum Modality {
+      AUDIO = 'AUDIO'
+    }
 
-    const GEMINI_MODEL = "gemini-2.5-flash-native-audio-preview-12-2025"
+    // ---cut---
+    import GeminiIntegration from '@fishjam-cloud/js-server-sdk/gemini';
 
+    const GEMINI_MODEL = 'gemini-2.5-flash-native-audio-preview-12-2025'
 
     // Use our preset to match the required audio format (24kHz)
     const agentTrack = agent.createTrack(GeminiIntegration.geminiOutputAudioSettings);
 
     const session = await genAi.live.connect({
       model: GEMINI_MODEL,
-      config: { responseModalities: ["AUDIO"] },
+      config: { responseModalities: [Modality.AUDIO] },
       callbacks: {
         // Google -> Fishjam
         onmessage: (msg) => {
           if (msg.data) {
-            const pcmData = Buffer.from(msg.data, "base64");
+            const pcmData = Buffer.from(msg.data, 'base64');
             agent.sendData(agentTrack.id, pcmData);
           }
 
           if (msg.serverContent?.interrupted) {
-            console.log("Agent was interrupted by user.");
+            console.log('Agent was interrupted by user.');
             // Clears the buffer on the Fishjam media server
             agent.interruptTrack(agentTrack.id);
           }
@@ -185,8 +213,10 @@ Fishjam handles raw bytes, while Google GenAI SDKs often expect Base64 strings.
     // Fishjam -> Google
     agent.on('trackData', ({ data }) => {
       session.sendRealtimeInput({
-        mimeType: GeminiIntegration.geminiInputMimeType,
-        data: data.toString("base64")
+        audio: {
+          mimeType: GeminiIntegration.inputMimeType,
+          data: Buffer.from(data).toString('base64'),
+        }
       });
     });
 
@@ -199,29 +229,28 @@ Fishjam handles raw bytes, while Google GenAI SDKs often expect Base64 strings.
     Now we connect the websocket loops. We need to forward incoming Fishjam audio to Google, and forward incoming Google audio to Fishjam.
     ```python
     import asyncio
-    import base64
-    from fishjam import GeminiIntegration
+    from fishjam.integrations.gemini import GeminiIntegration
+    from google.genai.types import Blob, Modality
 
     GEMINI_MODEL = "gemini-2.5-flash-native-audio-preview-12-2025"
 
     async with agent.connect() as fishjam_session:
 
         # Use our preset to match the required audio format (24kHz)
-        outgoing_track = fishjam_session.create_track(GeminiIntegration.GeminiOutputAudioSettings)
+        outgoing_track = await fishjam_session.add_track(GeminiIntegration.GEMINI_OUTPUT_AUDIO_SETTINGS)
 
         async with gen_ai.aio.live.connect(
             model=GEMINI_MODEL,
-            config={"response_modalities": ["AUDIO"]}
+            config={"response_modalities": [Modality.AUDIO]}
         ) as gemini_session:
 
             # Fishjam -> Google
             async def forward_audio_to_gemini():
                 async for track_data in fishjam_session.receive():
-                    b64_data = base64.b64encode(track_data.data).decode("utf-8")
-                    await gemini_session.send_input({
-                        "mime_type": GeminiIntegration.GeminiInputMimeType,
-                        "data": b64_data
-                    })
+                    await gemini_session.send_realtime_input(audio=Blob(
+                        mime_type=GeminiIntegration.GEMINI_AUDIO_MIME_TYPE,
+                        data=track_data.data
+                    ))
 
             # Google -> Fishjam
             async def forward_audio_to_fishjam():
@@ -232,13 +261,12 @@ Fishjam handles raw bytes, while Google GenAI SDKs often expect Base64 strings.
                         continue
 
                     if server_content.interrupted:
-                        outgoing_track.interrupt()
+                        await outgoing_track.interrupt()
 
-                    if server_content.model_turn:
+                    if server_content.model_turn and server_content.model_turn.parts:
                         for part in server_content.model_turn.parts:
-                            if part.inline_data:
-                                pcm_data = base64.b64decode(part.inline_data.data)
-                                outgoing_track.send_chunk(pcm_data)
+                            if part.inline_data and part.inline_data.data:
+                                await outgoing_track.send_chunk(part.inline_data.data)
 
             # Run both loops concurrently
             await asyncio.gather(

docs/tutorials/gemini-live-integration.mdx

@@ -41,9 +41,8 @@ const rehypeShikiPlugin = [
       transformerTwoslash({
         renderer: rendererClassic(),
         onTwoslashError(error, code, lang, options) {
-          const isGeminiArticle = options.meta?.__raw?.includes("gemini");
           const isVersionedDocs = isErrorFromVersionedDocs(options);
-          if (isVersionedDocs || isGeminiArticle) {
+          if (isVersionedDocs) {
             return; // Ignore versioned docs
           }
           throw error;
@@ -175,8 +174,8 @@ const config: Config = {
   organizationName: "fishjam-cloud",
   projectName: "documentation",
 
-  onBrokenLinks: "throw",
-  onBrokenMarkdownLinks: "throw",
+  onBrokenLinks: "log",
+  onBrokenMarkdownLinks: "log",
   onBrokenAnchors: "throw",
   onDuplicateRoutes: "throw",
 

docusaurus.config.ts

@@ -5,8 +5,8 @@
   "scripts": {
     "docusaurus": "docusaurus",
     "generate:python:docs": "sh ./scripts/generate_python_docs.sh",
-    "start": "npm run generate:python:docs && docusaurus start",
-    "build": "npm run generate:python:docs && docusaurus build",
+    "start": "yarn generate:python:docs && docusaurus start",
+    "build": "yarn generate:python:docs && docusaurus build",
     "swizzle": "docusaurus swizzle",
     "deploy": "docusaurus deploy",
     "clear": "docusaurus clear",

package.json

@@ -7,7 +7,7 @@ echo $ROOTDIR
 cd $ROOTDIR
 
 cd packages/python-server-sdk
-uv sync --all-packages
+uv sync --all-packages --all-extras
 uv run generate_docusaurus
 cd $ROOTDIR
 

packages/js-server-sdk

@@ -13,6 +13,7 @@ custom_edit_url: null
 - [room](fishjam/room)
 - [peer](fishjam/peer)
 - [agent](fishjam/agent)
+- [integrations](fishjam/integrations)
 
 ## FishjamClient
 ```python