# Create an instance of ActionExecutor
executor = ActionExecutor()

# Callback when any publish is received
def on_publish_received(publish_packet_data):
    publish_packet = publish_packet_data.publish_packet
    assert isinstance(publish_packet, mqtt5.PublishPacket)
    print("Received message from topic'{}':{}".format(publish_packet.topic, publish_packet.payload))
    global received_count
    received_count += 1

    # Add action to queue based on the received payload
    try:
        payload = json.loads(publish_packet.payload)
        action_name = payload.get("toolName")
        if action_name:
            executor.add_action_to_queue(action_name)
        else:
            print("No action specified in the payload")
    except json.JSONDecodeError:
        print("Invalid JSON payload received")

    if received_count == input_count:
        received_all_event.set()

…………….

    # Create MQTT5 client
    client = mqtt5_client_builder.mtls_from_path(
        endpoint=input_endpoint,
        port=input_port,
        cert_filepath=input_cert,
        pri_key_filepath=input_key,
        http_proxy_options=proxy_options,
        on_publish_received=on_publish_received,
        on_lifecycle_stopped=on_lifecycle_stopped,
        on_lifecycle_connection_success=on_lifecycle_connection_success,
        on_lifecycle_connection_failure=on_lifecycle_connection_failure,
        client_id=input_client_id,
        keep_alive_interval_sec=5,
    )
    print("MQTT5 Client Created")


You are a robot Command assistant. 
Your primary role is to assist the user by calling available tools to perform actions or physical tasks. 
Do not attempt to perform tasks directly; instead, rely on tools to achieve the desired outcomes. 
Keep your responses concise and focused on the task at hand.
Don't say anything similar to "can't command the robot to perform physical actions" or "I can't do that".
When the user asks you to perform a task, respond with the name of the tool that can be used to accomplish it.
For example, if the user asks you to "make the robot stand up", you should respond with "stand".

Available tools:
- stand: Command the robot to stand up and maintain a standing position.
- go_forward: Command the robot to move forward in the direction it is currently facing.
- back_fast: Command the robot to move backward quickly.
- left_move_fast: Command the robot to move left quickly.
- right_move_fast: Command the robot to move right quickly.
- sit_ups: Command the robot to perform sit-ups.
- turn_left: Command the robot to turn left.
- turn_right: Command the robot to turn right.
- wave: Command the robot to wave its hand.
- bow: Command the robot to bow.
- squat: Command the robot to squat down.
- chest: Command the robot to perform chest exercises.
- left_shot_fast: Command the robot to perform a fast left punch.
- right_shot_fast: Command the robot to perform a fast right punch.
- wing_chun: Command the robot to perform Wing Chun moves.
- left_uppercut: Command the robot to perform a left uppercut.
- right_uppercut: Command the robot to perform a right uppercut.
- left_kick: Command the robot to perform a left kick.
- right_kick: Command the robot to perform a right kick.
- stand_up_front: Command the robot to stand up from the front.
- stand_up_back: Command the robot to stand up from the back.
- twist: Command the robot to twist its body.
- stand_slow: Command the robot to stand up slowly.
- stepping: Command the robot to perform stepping motions.

export const DefaultToolSchema = JSON.stringify({
  type: "object",
  properties: {},
  required: [],
});

export const tools = [
  {
    toolSpec: {
      name: "stand",
      description:
        "Command the robot to stand up and maintain a standing position.",
      inputSchema: { json: DefaultToolSchema },
    },
  },
  {
    toolSpec: {
      name: "go_forward",
      description:
        "Command the robot to move forward in the direction it is currently facing.",
      inputSchema: { json: DefaultToolSchema },
    },
  },
……………
  {
    toolSpec: {
      name: "stepping",
      description: "Command the robot to perform stepping motions.",
      inputSchema: { json: DefaultToolSchema },
    },
  },
];


public setupPromptStartEvent(sessionId: string): void {
    console.log(`Setting up prompt start event for session ${sessionId}...`);
    const session = this.activeSessions.get(sessionId);
    if (!session) return;
    // Prompt start event
    this.addEventToSessionQueue(sessionId, {
      event: {
        promptStart: {
          promptName: session.promptName,
          textOutputConfiguration: {
            mediaType: "text/plain",
          },
          audioOutputConfiguration: DefaultAudioOutputConfiguration,
          toolUseOutputConfiguration: {
            mediaType: "application/json",
          },
          toolChoice: {
            any: {},
          },
          toolConfiguration: {
            tools: tools,
          },
        },
      },
    });
    session.isPromptStartSent = true;
  }


public async processToolUse(
    toolName: string,
    toolUseContent: any
  ): Promise<any> {
    // Implement the logic for processing tool use based on the toolName and toolUseContent
    console.log(`Processing tool use: ${toolName}`);
    console.log(`Tool use content:`, toolUseContent);

    if (!Object.keys(Actions).includes(toolName.toLocaleLowerCase())) {
      throw new Error(`Invalid tool name: ${toolName}`);
    }

    console.log("Processing directionTool with toolName:", toolName);
    if (this.robot === "all") {
      Array.from({ length: 6 }, (_, i) => i + 1).map((i) => {
        this.iotPublisher
          .publishToRobot(
            `robot_${i}/topic`,
            JSON.stringify({ toolName: toolName })
          )
          .catch(console.error);
      });
    } else {
      this.iotPublisher
        .publishToRobot(
          this.robot + `/topic`,
          JSON.stringify({ toolName: toolName })
        )
        .catch(console.error);
    }

    return {
      success: true,
      message: `Tool ${toolName} processed successfully.`,
    };
  }