Invalid schema for function 'X': schema must be a JSON Schema of 'type: "object"', got 'type: "None"'

import { jsonSchema } from 'ai';
import { tool } from 'ai';

const tools = {
  spreadsheet_set_cell: tool({
    description: 'Set a cell value in the active spreadsheet',
    parameters: jsonSchema<SpreadsheetSetCellInput>({
      type: 'object',
      properties: {
        row: { type: 'number', minimum: 0, description: 'Row index (0-based)' },
        col: { type: 'number', minimum: 0, description: 'Column index (0-based)' },
        value: { description: 'Cell value - can be string, number, boolean, or formula' },
        sheetId: { type: 'string', description: 'Sheet ID (optional)' },
      },
      required: ['row', 'col', 'value'],
      additionalProperties: false,
    }),
    execute: async (params) => {
      return await univerAgentBridge.executeCommand({
        action: 'setCellValue',
        params,
      });
    },
  }),
};

┌─────────────────────────────────────────────────────┐
│                   Next.js Frontend                  │
│  - React components with AG-UI client (@ag-ui/client) │
│  - Bidirectional state sync                         │
└─────────────────┬───────────────────────────────────┘
                  │
                  │ SSE/WebSocket (AG-UI Data Stream Protocol)
                  │
┌─────────────────▼───────────────────────────────────┐
│           Next.js API Route (TypeScript)            │
│  - AG-UI core (@ag-ui/core)                         │
│  - Tool definitions with JSON Schema (no Zod!)      │
│  - Vercel AI SDK for LLM streaming                  │
│  - Emit AG-UI protocol events via Data Stream       │
└─────────────────┬───────────────────────────────────┘
                  │
                  │ Supabase client
                  │
┌─────────────────▼───────────────────────────────────┐
│              Supabase Database                      │
│  (Existing schema - no changes needed)              │
└─────────────────────────────────────────────────────┘

npm install @ag-ui/core @ag-ui/client

import { Tool, EventType } from "@ag-ui/core";
import { createDataStream } from "ai";

// Define tools using AG-UI Tool type (avoids Zod entirely!)
const spreadsheetTools: Tool[] = [
  {
    name: "spreadsheet_set_cell",
    description: "Set a cell value in the active spreadsheet",
    parameters: {
      type: "object",
      properties: {
        row: { type: "number", minimum: 0 },
        col: { type: "number", minimum: 0 },
        value: {}, // Any type
        sheetId: { type: "string" }
      },
      required: ["row", "col", "value"]
    }
  },
  // ... other tools
];

// API Route: POST /api/agent
export async function POST(req: Request) {
  const { messages } = await req.json();

  const stream = createDataStream({
    execute: async (dataStream) => {

      // Emit AG-UI state update events
      dataStream.writeData({
        type: EventType.STATE_UPDATE,
        delta: { activeSheet: "sheet-1", focusMode: "sheet" }
      });

      // Use Vercel streamText with JSON Schema tools
      const result = streamText({
        model: openai('gpt-4o'),
        messages,
        tools: convertAGUIToolsToVercel(spreadsheetTools), // Convert once
        onToolCall: async ({ toolCall }) => {
          // Execute tool
          const result = await executeSpreadsheetTool(toolCall);

          // Emit AG-UI tool result event
          dataStream.writeData({
            type: EventType.TOOL_CALL_RESULT,
            toolCallId: toolCall.id,
            result
          });

          return result;
        }
      });

      // Merge LLM stream into data stream
      result.mergeIntoDataStream(dataStream);
    }
  });

  return stream.toDataStreamResponse();
}

// Helper: Convert AG-UI tools to Vercel format
function convertAGUIToolsToVercel(aguiTools: Tool[]) {
  return aguiTools.reduce((acc, t) => ({
    ...acc,
    [t.name]: tool({
      description: t.description,
      parameters: jsonSchema(t.parameters), // Use jsonSchema() to avoid Zod
      execute: async (params) => executeSpreadsheetTool({ name: t.name, params })
    })
  }), {});
}

import { useAGUIClient } from "@ag-ui/client";
import { EventType } from "@ag-ui/core";

function AgentConsole() {
  const { state, messages, sendMessage, subscribe } = useAGUIClient({
    url: "/api/agent"
  });

  // Subscribe to state updates
  useEffect(() => {
    const unsubscribe = subscribe(EventType.STATE_UPDATE, (event) => {
      // Update local UI state when agent changes it
      setWorkspaceContext(event.delta);
    });
    return unsubscribe;
  }, []);

  // Send message (agent can update state in response)
  const handleSubmit = async (message: string) => {
    await sendMessage(message);
  };

  return (
    <div>
      <div>Active Sheet: {state.activeSheet}</div>
      <ChatMessages messages={messages} />
      <ChatInput onSubmit={handleSubmit} />
    </div>
  );
}

┌─────────────────────────────────────────────────────┐
│                   Next.js Frontend                  │
│  - React components with AG-UI client               │
│  - Bidirectional state sync                         │
└─────────────────┬───────────────────────────────────┘
                  │
                  │ WebSocket (AG-UI protocol)
                  │
┌─────────────────▼───────────────────────────────────┐
│              FastAPI Backend (Python)               │
│  - LangGraph agent workflows                        │
│  - Pydantic tool schemas (no conversion issues!)    │
│  - AG-UI protocol adapter (@ag-ui/langgraph)        │
│  - State management & persistence                   │
└─────────────────┬───────────────────────────────────┘
                  │
                  │ Supabase client
                  │
┌─────────────────▼───────────────────────────────────┐
│              Supabase Database                      │
│  (Existing schema - no changes needed)              │
└─────────────────────────────────────────────────────┘

from langgraph.graph import StateGraph
from ag_ui.langgraph import LangGraphAdapter
from pydantic import BaseModel

# Define tool schemas with Pydantic (no conversion issues!)
class SpreadsheetSetCellInput(BaseModel):
    row: int
    col: int
    value: Any
    sheetId: Optional[str] = None

@tool
def spreadsheet_set_cell(input: SpreadsheetSetCellInput):
    """Set a cell value in the active spreadsheet"""
    return execute_spreadsheet_tool(input)

# LangGraph state machine
graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tools", tool_node)
graph.add_edge("agent", "tools")
graph.add_edge("tools", "agent")

# AG-UI protocol wrapper
adapter = LangGraphAdapter(graph)
app = adapter.create_fastapi_app()